操作系统试验报告.docx
《操作系统试验报告.docx》由会员分享，可在线阅读，更多相关《操作系统试验报告.docx（37页珍藏版）》请在冰豆网上搜索。
操作系统试验报告
❤❤❤❤大学❤❤学院
操作系统实验报告
姓名：
❤❤❤
年级：
❤❤❤
专业：
计算机科学与技术
学号：
❤❤❤❤❤❤❤❤❤❤
任课教师：
❤❤❤
开课时间：
2009~2010学年第二学期
实验
（一）
（多级反馈队列）
一、问题描述：
（四号黑体）
基于时间片轮转并结合优先权的调度算法，这种调度策略具有较好的性能，能够满足各类用户的需要。
二、程序分析与设计：
（四号黑体）
1、基本思想（四号仿宋，单倍行距）
∙将就绪进程分为两级或多级，系统相应建立两个或多个就绪进程队列，较高优先级的队列一般分配给较短的时间片。
处理器调度先从高级就绪进程队列中选取可占有处理器的进程，只有在选不到时，才从较低级的就绪进程队列中选取。
∙进程并非总是固定在某一队列中，新进程进入系统后，被存放在第一个队列的末尾。
如果某个进程在规定的时间片内没有完成工作，则把它转入到下一个队列的末尾，直至进入最后一个队列。
系统先运行第一个队列中的进程。
当第一队列为空时，才运行第二个队列中的进程。
依此类推，仅当前面所有的队列都为空时，才运行最后一个队列中的进程。
2、结构定义（四号仿宋，单倍行距）
typedefstructnode/*进程节点信息*/
{
charname[20];/*进程的名字*/
intprio;/*进程的优先级*/
intround;/*分配CPU的时间片*/
intcputime;/*CPU执行时间*/
intneedtime;/*进程执行所需要的时间*/
charstate;/*进程的状态，W--就绪态，R--执行态，F--完成态*/
intcount;/*记录执行的次数*/
structnode*next;/*链表指针*/
}PCB;
typedefstructQueue/*多级就绪队列节点信息*/
{
PCB*LinkPCB;/*就绪队列中的进程队列指针*/
intprio;/*本就绪队列的优先级*/
intround;/*本就绪队列所分配的时间片*/
structQueue*next;/*指向下一个就绪队列的链表指针*/
}ReadyQueue;
3、算法描述（四号仿宋，单倍行距）
#include
#include
#defineReadyNum3
#defineProNum5
typedefstructnode/*进程节点信息*/
{
charname[20];/*进程的名字*/
intneedtime;/*进程执行所需要的时间*/
charstate;/*进程的状态，W——就绪态，R——执行态，F——完成态*/
intcount;/*记录执行的次数*/
structnode*next;/*链表指针*/
structnode*head;
structnode*rear;
}PCB;
typedefstructQueue/*多级就绪队列节点信息*/
{structQueue*head;
PCBLinkPCB[100];
structQueue*rear;
intround;/*本就绪队列所分配的时间片*/
structQueue*next;/*指向下一个就绪队列的链表指针*/
}ReadyQueue;
intNum;
intm=0;
intb=0;
ReadyQueueQueue[ReadyNum];
voidInsertPrio（）;/*创建就绪队列，规定优先数越小，优先级越低*/
voidMultiDispatch（）;/*多级调度算法，每次执行一个时间片*/
intprintn=0;
voidprint（PCBp1）;
voidcreatprint（PCBp1）;
PCBprinthead[ProNum];
usingnamespacestd;
voidInsertPrio（）//设置每个队列的时间片
{inti;
for（i=0;i{
cout<<"请输入第"<"<cin>>Queue[i].round;
}
}
voidInsertFinish（intm）//创建第一个就绪队列
{inti=0;
PCBp1;
cout<<"请输入进程信息"<cout<<"进程名和需要的执行时间"<for（i=0;i{p1.count=0;
cin>>p1.name;
cin>>p1.needtime;
Queue[0].LinkPCB[i]=p1;
}
}
voidInsert（PCBp1）//创建第二个就绪队列
{PCB*head;
Queue[1].LinkPCB[m]=p1;m++;
}
voidInsert2（PCBp1）//创建第三个就绪队列
{PCB*p2;
Queue[2].LinkPCB[b]=p1;b++;
}
voidMultiDispatch（intq）
{inti=0,j;intflag=1;
PCBp1;intu=0;intu1=0;intu2=0;
p1=Queue[0].LinkPCB[i];
for（i=0;i{p1=Queue[0].LinkPCB[u];
u++;
if（（（p1.needtime-Queue[0].round）<=0））
{p1.state='F';p1.count++;print（p1）;
}
else{p1.needtime=p1.needtime-Queue[0].round;Insert（p1）;}
}
p1=Queue[1].LinkPCB[0];
for（i=0;i{p1=Queue[1].LinkPCB[u1];
u1++;
if（（（p1.needtime-Queue[1].round）<=0））
{p1.state='F';p1.count=p1.count+2;print（p1）;
}
else{p1=Queue[1].LinkPCB[u1-1];p1.needtime=p1.needtime-Queue[1].round;Insert2（p1）;}
}
p1=Queue[2].LinkPCB[0];
for（i=0;i{p1=Queue[2].LinkPCB[u2];
u2++;
if（（（p1.needtime-Queue[2].round）<=0））
{p1.state='F';p1.count=p1.count+3;print（p1）;
}
else{p1.state='w';p1.count=0;print（p1）;}
}
}
voidprint（PCBp1）
{intn=0;
if（printn==0）{printhead[printn]=p1;printn++;}
else{printhead[printn]=p1;printn++;}
}
voidOutput（）
{intn=0;
cout<<"进程名"<<""<<"进程状态"<<""<<"进程轮转次数"<<""<while（n{cout<n++;
}
}
intmain（）
{printf（"固定三个就绪队列，5个进程数\n"）;
inti;
InsertPrio（）;
InsertFinish（m）;
MultiDispatch（m）;
Output（）;
system（"PAUSE"）;
returnEXIT_SUCCESS;
}三、调试与运行：
四、总结：
（四号黑体）
1、本程序的优点和不足之处（四号仿宋，单倍行距）
操作简单直观明了，但没有完全模拟出算法，如果进程所需时间过大，不能显示出完成的。
仍然处于等待状态。
固定了就绪队列的个数和进程的个数。
只是简单的模拟了多级反馈算法思路。
2、心得体会（四号仿宋，单倍行距）
对多级反馈队列调度算法更熟悉了一些
实验
（二）
（页面置换）
一、问题描述：
主要包括三种典型的置换算法：
最佳适用（OPT）算法，先进先出（FIFO）算法，最久未使用（URL）算法。
二、程序分析与设计：
1、基本思想
A.最佳适用算法：
所选择的淘汰页是以后永不使用或者以后最长时间不需要访问的页，是一种理想化的算法，具有最好的性能，通常可以保证最低的缺页率。
实现方法：
利用一个与内存块相同大小的数组记录以后的重复出现的页面位置，如未出现则为最大，然后对这个数组进行比较，选出位置最大的页予以淘汰。
B．先进先出算法：
总是淘汰最先进入内存的页，也就是将内存中中驻留时间最久的页面。
实现方法：
在内存块数组中，按顺序存入数组，依次淘汰，即最先进来的先淘汰。
C．最久未使用算法：
根据页面调入内存后的使用情况进行决策，选择最近最久未使用的页面予以淘汰。
实现方法：
每次将页面存入内存数组栈顶，然后下面的一次向下移，在栈底位置的页面为下一次要淘汰的页。
2、结构定义
#defineN10//页面数
inta[N],b[32];//a[]为要调入内存的页面，b[]为内存块数组
while（f）//对内存块数组进行初始化
{for（j=0;j{
b[j]=-1;
}
3、算法描述
#include
#include
#defineN10
usingnamespacestd;
inta[N],b[32];//a[]为要调入内存的页面，b[]为内存块数组
voidOptimal（intm）
{
cout<<"\nOPT算法置换\n"<inti=0,j=0,count=0,k;
while（i{
for（k=0;k{
if（b[k]==a[i]）
{
cout<<"内存中有这个页面,直接访问."<break;
}
}//判断内存中是否有该页面.
if（k==m）
if（b[m-1]<0）//内存未满的情况//
{
b[j]=a[i];
cout<count++;
cout<<"产生"<j++;
j=j%m;
}
else
{inttemp[4];//存储内存块中的页号在下一次使用的位置
inth=j;
while（a[h]!
=b[0]&&h++h;
temp[0]=h;h=j;
while（a[h]!
=b[1]&&h++h;
temp[1]=h;h=j;
while（a[h]!
=b[2]&&h++h;
temp[2]=h;h=j;
while（a[h]!
=b[3]&&h++h;
temp[3]=h;
intmax_x=0;//最后定位要换出的页号所在的内存号
intmax=temp[0];
for（intc=0;c<4;++c）//找出要置换的页号//
if（temp[c]>max）
{max=temp[c];max_x=c;
}
count++;
cout<b[max_x]=a[i];
}
i++;
}cout<cout<<"共缺页"<"<}
////-------------FIFO算法置---------------////
voidFIFO（intm）
{
cout<<"\nFIFO算法置换\n"<inti=0,j=0,count=0,k;
while（i<10）
{
for（k=0;k{
if（b[k]==a[i]）
{
cout<<"内存中有这个页面,直接访问."<break;
}
}//判断内存中是否有该页面.
if（k==m）
{
if（b[m-1]<0）
{
b[j]=a[i];
cout<count++;
cout<<"产生"<j++;
j=j%m;
}
else
{
count++;
cout<b[j]=a[i];
j++;
j=j%m;
}
}
i++;
}cout<cout<<"共缺页"<"<}
///////---------------LRU算法--------------///////////////
voidLRU（intm）
{
cout<<"\nLRU算法置换\n"<intk;
inti=0,j=0,count=0;
while（i<10）
{
for（k=0;k{
if（b[k]==a[i]）
{
cout<<"内存中有这个页面,直接访问."<break;
}
}//判断内存中是否有该页面.
if（k==m）
{inttemp,t;
temp=b[m-1];
for（t=0;tb[0]=a[i];
count++;
if（temp==-1）
cout<else
cout<}
i++;
}
cout<cout<<"共缺页"<"<}
intmain（intargc,char*argv[]）
{
intsf,f=1,m,i,j,n;
cout<<"请输入内存容量:
";
cin>>m;
cout<<"请输入页面次序:
（"<for（i=0;i{
cin>>n;
a[i]=n;
}
//初始化b[j];使等于-1,表示开始时内存中无页面.
while（f）
{for（j=0;j{
b[j]=-1;
}
cout<<"请输入页面置换算法：
1、最佳置换算法2、先进先出算法3、最近最久为未使用算法"<cin>>sf;
switch（sf）
{case1:
Optimal（m）;break;
case2:
FIFO（m）;break;
case3:
LRU（m）;break;
default:
cout<<"@选择错误！
"<}
cout<cout<<"是否继续,按1继续，按0退出"<cin>>f;
}
system（"PAUSE"）;
returnEXIT_SUCCESS;
}三、调试与运行：
四、总结：
1、本程序的优点和不足之处（四号仿宋，单倍行距）
操作简单明了，结果用表格形式表现将会更直观
2、心得体会（四号仿宋，单倍行距）
三种页面置换算法FIFO,LRU,OPT,容易理解,但在实际实现过程的时候要注意各种细节。
对算法的时间复杂度的分析还是不熟悉
实验（三）
银行家算法
一、问题描述：
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
二、程序分析与设计：
1、基本思想
（1）,进程一开始向系统提出最大需求量.
（2）,进程每次提出新的需求都统计是否超出它事先提出的最大需求量.
（3）,若正常,则判断该进程所需剩余剩余量（包括本次申请）是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待.
2、结构定义
intMax[100][100]={0};//各进程所需各类资源的最大需求
intAvaliable[100]={0};//系统可用资源
charname[100]={0};//资源的名称
intAllocation[100][100]={0};//系统已分配资源
intNeed[100][100]={0};//还需要资源
intRequest[100]={0};//请求资源向量
inttemp[100]={0};//存放安全序列
intWork[100]={0};//存放系统可提供资源
intM=100;//作业的最大数为100
intN=100;//资源的最大数为100
3、算法描述
#include
#include
#include
#defineFalse0
#defineTrue1
intMax[100][100]={0};//各进程所需各类资源的最大需求
intAvaliable[100]={0};//系统可用资源
charname[100]={0};//资源的名称
intAllocation[100][100]={0};//系统已分配资源
intNeed[100][100]={0};//还需要资源
intRequest[100]={0};//请求资源向量
inttemp[100]={0};//存放安全序列
intWork[100]={0};//存放系统可提供资源
intM=100;//作业的最大数为100
intN=100;//资源的最大数为100
voidshowdata（）//显示资源矩阵
{
inti,j;
cout<<"系统目前可用的资源[Avaliable]:
"<for（i=0;icout<cout<for（j=0;jcout<cout<cout<<"MaxAllocationNeed"<cout<<"进程名";
for（j=0;j<3;j++）
{
for（i=0;icout<cout<<"";
}
cout<for（i=0;icout<<""<for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<}
}
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;jAvaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return1;
}
intsafe（）//安全性算法
{
inti,k=0,m,apply,Finish[100]={0};
intj;
intflag=0;
for（i=0;iWork[i]=Avaliable[i];
for（i=0;iapply=0;
for（j=0;jif（Finish[i]==False&&Need[i][j]<=Work[j]）
{
apply++;
if（apply==N）
{
for（m=0;mWork[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for（i=0;iif（Finish[i]==False）{
cout<<"系统不安全"<return-1;
}
}
cout<<"系统是安全的!
"<cout<<"分配的序列:
";
for（i=0;icout<if（i";
}
cout<return0;
}
voidshare（）//利用银行家算法对申请资源对进行判定
{
charch;
inti=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号（0-"<";
cin>>i;//输入须申请的资源号
cout<<"请输入进程"<"<for（j=0;j{
cout<";
cin>>Reques
升级会员 