完整word版进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料word文档良心出品.docx
《完整word版进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料word文档良心出品.docx》由会员分享，可在线阅读，更多相关《完整word版进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料word文档良心出品.docx（45页珍藏版）》请在冰豆网上搜索。
完整word版进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料word文档良心出品
江苏科技大学
操作系统实验报告
（2015/2016学年第2学期）
课程名称：
操作系统
指导教师：
实验地点：
西校区图书馆计算机机房
学生姓名：
学生学号：
院系：
计算机科学与工程学院
专业：
计算机科学与技术
2016年5月15日
实验一进程调度
一、实验目的
多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、实验内容
1．优先权法、轮转法
简化假设
1）进程为计算型的（无I/O）
2）进程状态：
ready、running、finish
3）进程需要的CPU时间以时间片为单位确定
2．算法描述
1）优先权法——动态优先权
当前运行进程用完时间片后，其优先权减去一个常数。
2）轮转法
三、实验要求
1．产生的各种随机数的取值范围加以限制，如所需的CPU时间限制在1~20之间。
2．进程数n不要太大通常取4~8个
3．使用动态数据结构
4．独立编程
5．二种调度算法
四、实验过程
//秦魏编写要拷贝使用无（fa）偿（ge）使（hong）用（bao）
#ifndefMaxpriority_H
#defineMaxpriority_H
#definearrayLenth100;
template
classMaxheap{
T*heap;
intheapsize,lenth;
public:
Maxheap（intn）{lenth=0;
heapsize=n;
heap=newT[heapsize];
}
Maxheap（T*maxheap,intn）{
if（n<0）return;
lenth=n;
heapsize=n;
heap=newT[heapsize];
inti;
for（i=0;iheap[i]=maxheap[i];
create（）;
}
~Maxheap（）{delete[]heap;}
intParent（inti）{return（i+1）/2-1;//注意地址的转换，最后还要减去1
}
intLchild（inti）{return2*（i+1）-1;}
intRchild（inti）{return2*i+2;}
voidMaxheapify（inti）{
intl,r;
l=Lchild（i）;
r=Rchild（i）;
intlargest;
if（lheap[i].priority）//第一个条件，起到一个判断是否为叶子节点的作用
largest=l;
elselargest=i;
if（rheap[largest].priority）
largest=r;
if（largest!
=i）swap（heap[largest],heap[i]）,
Maxheapify（largest）;
}
voidswap（T&a,T&b）{
Tstore;
store=a;
a=b;
b=store;
}
voidcreate（）{
inti;
for（i=lenth/2-1;i>=0;i--）
Maxheapify（i）;
}
voidinsert（T&element）{
lenth++;
heap[lenth-1]=element;
create（）;
}
voidprint（）{
inti;
for（i=0;icout<}
intheapextractmax（）{
if（lenth==0）return-1;
Tmax;
max=heap[0];
heap[0]=heap[lenth-1];
lenth--;
Maxheapify（0）;
returnmax.task;
}
intempty（）{if（lenth==0）return1;
return0;
}
};
#endif
#ifndefQuene_H
#defineQuene_H
#definesize1000
//队列先进先出，从队尾进，从对头出
template
classCirquene{
Ta[size];
intfront,rear;
public:
Cirquene（）{front=rear=size-1;}
~Cirquene（）{}
voidEnquene（T&e）{if（（rear+1）%size==front）throw"上溢";
rear=（rear+1）%size;
a[rear]=e;
}
intDequene（）{if（rear==size）throw"下溢";
if（Empty（））return-1;
else{
front=（front+1）%size;
returna[front].task;
}
}
intGetfront（）{
returnfront;}
intEmpty（）{
if（front==rear）return1;
return0;}
voidprint（）{
datatypee=a[rear];
inti;
do{
i=e.pre;
cout<e=a[i];
}while（i!
=-1）;//注意这边i的取值
}
};
#endif
#include
#include"Maxheap.h"
#include"Quene.h"
usingnamespacestd;
enumState{//enum变量后用逗号隔开！
！
！
！
！
ready,
exe,
blo,
fin,
};//任务状态
structPCB//优先级队列通过堆排序实现
{
inttask;//任务
intpriority;//优先级
intAexeTime;//已经运行时间
intSexeTime;//剩余运行时间
intblocktime;//阻塞时间
Statestate;//任务状态
};
intcheckstate（PCB*program）{inti;//检查是否所有程序都已运行结束
for（i=0;i<5;i++）
if（program[i].state!
=fin）return0;
return1;
}
voidPSA（MaxheapTest,PCB*program,intArrtime[],intquantum）{//1个单位时间检查一次用堆排序实现优先级队列
intm=0,alltime=0,num=0,k,time=0;
while（!
checkstate（program））{
if（num<5）
for（m=0;m<5;m++）
if（alltime==Arrtime[m]）Test.insert（program[m]）,
cout<<"进程"<num++,program[m].state=ready;//到达到达时间进入就绪队列
if（alltime==0||k==-1）k=Test.heapextractmax（）;//在无进程运行后序有进程进入时应该抛出！
！
！
！
alltime++,time++;
if（k==-1）cout<<"从"<if（k!
=-1）{
program[k].state=exe,
program[k].AexeTime++,
program[k].SexeTime--,
program[k].priority-=3,//优先级减3
cout<<"从"<if（program[k].SexeTime==0）program[k].state=fin,time=0,
cout<<"进程"<k=Test.heapextractmax（）;
if（program[k].SexeTime!
=0&&time==quantum）program[k].state=ready,
Test.insert（program[k]）,time=0,k=Test.heapextractmax（）;
}
}
}
voidRR（PCB*program,inti,intArrtime[],intquantum）{//优先级列表用队列实现
intm,k,num=0,alltime=0,time=0;
Cirquenepriority;
while（!
checkstate（program））{
if（alltime==0）for（m=0;mif（alltime==Arrtime[m]）priority.Enquene（program[m]）,
cout<<"进程"<num++,program[m].state=ready;//找到第一个到达的进程
if（alltime==0||k==-1）k=priority.Dequene（）;//开始调度
alltime++,time++;
if（alltime!
=0&&numif（alltime==Arrtime[m]）priority.Enquene（program[m]）,
cout<<"进程"<num++,program[m].state=ready;
if（k==-1）cout<<"从"<else{
program[k].state=exe,
program[k].AexeTime++,
program[k].SexeTime--;
cout<<"从"<if（program[k].SexeTime==0）
program[k].state=fin,
time=0,
cout<<"进程"<if（time==quantum）
if（program[k].SexeTime!
=0）program[k].state=ready,priority.Enquene（program[k]）,
k=priority.Dequene（）,time=0;
}
}
}
intmain（）{
inttask[5]={0,1,2,3,4};//任务
intExeTime[5]={5,5,3,1,3};//运行时间
intpriority[5]={2,5,2,4,3};//优先级
intArrTime[5]={4,3,2,0,4};//到达时间
PCBprogram[5],program2[5];
inti;
for（i=0;i<5;i++）
{
program[i].task=task[i],program2[i].task=task[i];
program[i].priority=priority[i],program2[i].priority=priority[i];
program[i].AexeTime=0,program2[i].AexeTime=0;
program[i].SexeTime=ExeTime[i],program2[i].SexeTime=ExeTime[i];
program[i].blocktime=0,program2[i].blocktime=0;
program[i].state=blo,program2[i].state=blo;
}//初始化pcb*/
MaxheapTest（5）;
intquantum=2;//时间片为2
cout<<"优先权法:
"<PSA（Test,program,ArrTime,quantum）;
cout<<"轮转调度法:
"<RR（program2,5,ArrTime,quantum）;
system（"pause"）;
return0;
}
五、实验分析与实现
1.轮转法调度，具有先进先出的特点，所以利用队列实现
2.优先级调度算法具有优先级动态变化的特点，每一次进行优先级要排序。
所以优先级队列通过堆来实现
六、实验过程中的问题及对应思考
动态优先级调度算法：
这种调度算法根据进程的资源需求来动态地分配进程的优先级，其目的就是在资源分配和调度时有更大的灵活性.在实时系统中，最早期限优先算法（EDF）算法是使用最多的一种动态优先级调度算法，该算法给就绪队列中的各个进程根据它们的截止期限（Deadline）来分配优先级，具有最近的截止期限的进程具有最高的优先级.
轮转法：
系统将所有就绪进程按FIFO规则排队，按一定的时间间隔把处理机分配给队列中的进程。
这样，就绪队列中所有进程均可获得一个时间片的处理机而运行。
虽然实验原理比较简单，但是在编写代码的过程中遇到了不少的问题，在两个小时之内已经完成的大体代码的编写，但是之中存在不少的问题，导致了用了差不多四个小时的时间去调试才把它弄好，这主要归咎于在开始设计代码的不太合理，在后期使得代码结构有些混乱，使得调试更加的麻烦，以及对编程的不熟悉。
通过这个实验不仅使我对进程的调度算法有了更深的认识，使得理论知识得到的实践，也使我的编程能力得到了进一步提高。
实验二银行家算法
一、实验目的
死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验内容
银行家算法
三、实验要求
设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；
四、实验过程
#include
usingnamespacestd;
voidMatrixminus（inta[][10],intb[][10],intc[][10],intm,intn）{
inti,k;
for（i=0;ifor（k=0;kc[i][k]=a[i][k]-b[i][k];
}
voidInitialize（inta[][10],intm,intn）{
intc,b;
for（c=0;cfor（b=0;bcin>>a[c][b];
}
voidAdd（inta[],intb[][10],intm,intn）{
inti;
for（i=0;ia[i]=a[i]+b[m][i];
}
voidMatrixprint（inta[][10],intm,intn）{
inti,k;
for（k=0;kfor（i=0;icout<}
intCompare（intwork[],intneed[][10],intm,intn）{
inti;
for（i=0;iif（need[m][i]>work[i]）return0;
return1;
}
intCompare2（intrequest[][10],intavailable[],intm,intn）{
inti;
for（i=0;iif（available[i]return1;
}
intCheck（intm,intn,intAvailable[10],intMax[10][10],intAllocation[10][10],intNeed[10][10]）{
int*Work;
int*Finish;
Finish=newint[m];
Work=newint[n];
inti,k;
for（i=0;iFinish[i]=0;
for（i=0;iWork[i]=Available[i];
for（k=0;kfor（i=0;iif（Compare（Work,Need,i,n）&&Finish[i]==0）{
Add（Work,Allocation,i,n）,Finish[i]=1;
}
}
for（k=0;kif（Finish[k]==0）return0;
return1;
}
voidBankeralgorithm（intn,intm,intAvailable[],intMax[][10],intAllocation[][10],intNeed[][10],intrequest[10][10],intk）{
inta;
for（a=0;aif（request[k][a]>Need[k][a]）return;
while（!
Compare2（request,Available,k,n））{
}
for（a=0;a{
Available[a]=Available[a]-request[k][a];
Allocation[k][a]=Allocation[k][a]+request[k][a];
Need[k][a]=Need[k][a]-request[k][a];
}
if（!
Check（m,n,Available,Max,Allocation,Need））{
cout<<"分配失败"<for（a=0;a{
Available[a]=Available[a]+request[k][a];
Allocation[k][a]=Allocation[k][a]-request[k][a];
Need[k][a]=Need[k][a]+request[k][a];
}
}
elsecout<<"分配成功"<}
intmain（）{
intAvailable[10],Max[10][10],Allocation[10][10],Need[10][10],request[10][10];
intm,n;
cout<<"请输入进程个数和资源种类的个数"<cin>>m>>n;
cout<<"请输入可分配资源"<inti;
for（i=0;icin>>Available[i];
cout<<"请输入进程最大所需资源"<Initialize（Max,m,n）;
cout<<"请输入已分配资源"<Initialize（Allocation,m,n）;
intk;
cout<<"请输入要申请资源的进程"<cin>>k;
cout<<"请输入要分配的资源
升级会员 