进程调度存储器管理 银行家算法 磁盘调度操作系统实验报告文档格式.docx
- 文档编号:18608285
- 上传时间:2022-12-29
- 格式:DOCX
- 页数:38
- 大小:104.83KB
进程调度存储器管理 银行家算法 磁盘调度操作系统实验报告文档格式.docx
《进程调度存储器管理 银行家算法 磁盘调度操作系统实验报告文档格式.docx》由会员分享,可在线阅读,更多相关《进程调度存储器管理 银行家算法 磁盘调度操作系统实验报告文档格式.docx(38页珍藏版)》请在冰豆网上搜索。
//秦魏编写要拷贝使用无(fa)偿(ge)使(hong)用(bao)
#ifndefMaxpriority_H
#defineMaxpriority_H
#definearrayLenth100;
template<
classT>
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;
i<
heapsize;
i++)
heap[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(l<
lenth&
&
heap[l].priority>
heap[i].priority)//第一个条件,起到一个判断是否为叶子节点的作用
largest=l;
elselargest=i;
if(r<
lenth&
heap[r].priority>
heap[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(){
for(i=lenth/2-1;
i>
=0;
i--)
Maxheapify(i);
voidinsert(T&
element){
lenth++;
heap[lenth-1]=element;
voidprint(){
lenth;
cout<
<
heap[i].priority;
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
//队列先进先出,从队尾进,从对头出
classCirquene{
Ta[size];
intfront,rear;
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.x<
'
\t'
<
e.y<
endl;
e=a[i];
}while(i!
=-1);
//注意这边i的取值
#include<
iostream>
#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;
5;
if(program[i].state!
=fin)return0;
return1;
voidPSA(Maxheap<
PCB>
Test,PCB*program,intArrtime[],intquantum){//1个单位时间检查一次用堆排序实现优先级队列
intm=0,alltime=0,num=0,k,time=0;
while(!
checkstate(program)){
if(num<
5)
for(m=0;
m<
m++)
if(alltime==Arrtime[m])Test.insert(program[m]),
cout<
"
进程"
m+1<
到达"
endl,
num++,program[m].state=ready;
//到达到达时间进入就绪队列
if(alltime==0||k==-1)k=Test.heapextractmax();
//在无进程运行后序有进程进入时应该抛出!
alltime++,time++;
if(k==-1)cout<
从"
alltime-1<
到"
alltime<
单位时间无进程运行"
if(k!
=-1){
program[k].state=exe,
program[k].AexeTime++,
program[k].SexeTime--,
program[k].priority-=3,//优先级减3
cout<
alltime-1<
单位时间"
k+1<
进程运行"
if(program[k].SexeTime==0)program[k].state=fin,time=0,
k+1<
在"
alltime<
单位时间运行结束"
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;
Cirquene<
priority;
if(alltime==0)for(m=0;
i;
if(alltime==Arrtime[m])priority.Enquene(program[m]),
//找到第一个到达的进程
if(alltime==0||k==-1)k=priority.Dequene();
//开始调度
if(alltime!
=0&
num<
i)for(m=0;
m++)//先判断下一个时刻是否有进程到达原因是在一个进程运行结束同时另外一个进程到达到达的那个进程应该首先进入就绪队列
if(alltime==Arrtime[m])priority.Enquene(program[m]),
num++,program[m].state=ready;
if(k==-1)cout<
alltime-1<
else{
program[k].SexeTime--;
cout<
if(program[k].SexeTime==0)
program[k].state=fin,
time=0,
endl,k=priority.Dequene();
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];
for(i=0;
i<
5;
{
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*/
Maxheap<
Test(5);
intquantum=2;
//时间片为2
cout<
优先权法:
"
PSA(Test,program,ArrTime,quantum);
轮转调度法:
RR(program2,5,ArrTime,quantum);
system("
pause"
);
五、实验分析与实现
1.轮转法调度,具有先进先出的特点,所以利用队列实现
2.优先级调度算法具有优先级动态变化的特点,每一次进行优先级要排序。
所以优先级队列通过堆来实现
六、实验过程中的问题及对应思考
动态优先级调度算法:
这种调度算法根据进程的资源需求来动态地分配进程的优先级,其目的就是在资源分配和调度时有更大的灵活性.在实时系统中,最早期限优先算法(EDF)算法是使用最多的一种动态优先级调度算法,该算法给就绪队列中的各个进程根据它们的截止期限(Deadline)来分配优先级,具有最近的截止期限的进程具有最高的优先级.
轮转法:
系统将所有就绪进程按FIFO规则排队,按一定的时间间隔把处理机分配给队列中的进程。
这样,就绪队列中所有进程均可获得一个时间片的处理机而运行。
虽然实验原理比较简单,但是在编写代码的过程中遇到了不少的问题,在两个小时之内已经完成的大体代码的编写,但是之中存在不少的问题,导致了用了差不多四个小时的时间去调试才把它弄好,这主要归咎于在开始设计代码的不太合理,在后期使得代码结构有些混乱,使得调试更加的麻烦,以及对编程的不熟悉。
通过这个实验不仅使我对进程的调度算法有了更深的认识,使得理论知识得到的实践,也使我的编程能力得到了进一步提高。
实验二银行家算法
死锁会引起计算机工作僵死,因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。
银行家算法
设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源,以及系统动态分配资源的过程,便于用户观察和分析;
voidMatrixminus(inta[][10],intb[][10],intc[][10],intm,intn){
inti,k;
m;
for(k=0;
k<
n;
k++)
c[i][k]=a[i][k]-b[i][k];
voidInitialize(inta[][10],intm,intn){
intc,b;
for(c=0;
c<
c++)
for(b=0;
b<
b++)
cin>
>
a[c][b];
voidAdd(inta[],intb[][10],intm,intn){
a[i]=a[i]+b[m][i];
voidMatrixprint(inta[][10],intm,intn){
for(k=0;
a[k][i];
intCompare(intwork[],intneed[][10],intm,intn){
if(need[m][i]>
work[i])return0;
return1;
intCompare2(intrequest[][10],intavailable[],intm,intn){
if(available[i]<
request[m][i])return0;
}
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;
Finish[i]=0;
Work[i]=Available[i];
k++)
i++){
if(Compare(Work,Need,i,n)&
Finish[i]==0){
Add(Work,Allocation,i,n),Finish[i]=1;
if(Finish[k]==0)return0;
voidBankeralgorithm(intn,intm,intAvailable[],intMax[][10],intAllocation[][10],intNeed[][10],intrequest[10][10],intk){
inta;
for(a=0;
a<
a++)
if(request[k][a]>
Need[k][a])return;
Compare2(request,Available,k,n)){
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)){
分配失败"
for(a=0;
{
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<
分配成功"
intAvailable[10],Max[10][10],Allocation[10][10],Need[10][10],request[10][10];
intm,n;
请输入进程个数和资源种类的个数"
cin>
m>
请输入可分配资源"
cin>
Available[i];
请输入进程最大所需资源"
Initialize(Max,m,n);
请输入已分配资源"
Initialize(Allocation,m,n);
intk;
请输入要申请资源的进程"
k;
请输入要分配的资源的数量"
endl;
f
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 进程调度 存储器管理 银行家算法 磁盘调度 操作系统实验报告 进程 调度 存储器 管理 银行家 算法 磁盘 操作系统 实验 报告
![提示](https://static.bdocx.com/images/bang_tan.gif)