操作系统课程设计报告.docx
《操作系统课程设计报告.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计报告.docx（99页珍藏版）》请在冰豆网上搜索。
操作系统课程设计报告
操作系统
实
验
报
告
学院：
计算机科学与技术学院
班级：
计091
学号：
0913022032
姓名：
曹恒楼
时间：
2011/1/3
1.主界面……………………………………………………3
2.设计说明…………………………………………………3
3.子功能详细设计…………………………………………5
3.1作业调度算法………………………………………5
3.2银行家算法…………………………………………13
3.3页面调度算法………………………………………20
3.4驱动调度算法………………………………………30
4.附录（算法源代码）………………………………………38
设计内容：
将四次实验的内容整合起来，封装成一个可执行文件
主界面：
使用说明：
须将整个文件直接放在D盘下，不可放在其他盘符，不可放在D盘子文件夹下。
利用MFC完成，每次选择一项完成，若没有，则可选择关闭退出。
每一个子功能都是前面的算法，没有作多少补充。
作业调度算法：
银行家算法：
页面调度算法：
驱动调度算法：
功能一：
作业调度算法
一、实验名称：
用C++实现作业调度算法
二、实验目的：
通过自己编程来实现各个调度算法，进一步理解进程调度各种算法的概念及含义，提高对算法的认识，同时提高自己的动手实践能力。
三、实验内容：
利用C++,实现进程调度算法,有先来先服务、优先级调度、短作业优先、响应比高优先，这四个算法。
四、实验要求：
1.至少完成三个进程调度算法的设计
2.分别计算出算法实现的平均作业周转时间、平均带权作业周转时间。
五、实验环境：
Win-7系统
VisualC++6.0
六、实验设计：
1.数据结构设计
定义结构体：
（对不同算法，均按此结构定义）
structtask_struct//定义结构体
{
charname[10];//进程名称
floatcome_time;//到达时间
floatrun_begin_time;//开始运行时间
floatrun_time;//运行时间
floatrun_end_time;//运行结束时间
intpriority;//优先级
intorder;//运行次序
intrun_flag;//调度标志
};
2.算法设计
1）FCFS算法
先来先服务，利用冒泡排序，按照进程到达时间进行排序
voidbubble（floataa[],intcounter）//用来对fcfs采用冒泡排序
{
floatt;
for（inta=1;afor（intb=0;b{
if（aa[b]>aa[b+1]）
{t=aa[b];aa[b]=aa[b+1];aa[b+1]=t;}
}
}
计算周转时间
intfcfs（）//先来先服务
{
floattime_temp=0;//临时时间
float*aa=newfloat[counter];//为冒泡排序的实现，创建一个新的数组
inti;
intnumber_schedul;
time_temp=tasks[0].come_time;
for（intc=0;c{
aa[c]=tasks[c].come_time;
}
bubble（aa,counter）;//调用冒泡函数进行排序
for（intd=0;dfor（inte=0;e{
if（aa[d]==tasks[e].come_time）//处理顺序即为排序后的顺序
tasks[e].order=d+1;
}
for（i=0;i{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schedul=i;
}
return0;
}
2）SJF算法
intsjf（）//短作业优先
{
floattemp_time=0;
inti=0,j;
intnumber_schedul,temp_counter;
floatrun_time;
run_time=tasks[i].run_time;//初始化运行时间
j=1;
while（（j{
if（tasks[j].run_time{
run_time=tasks[j].run_time;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程求相应的参数
number_schedul=i;
tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;
temp_time=tasks[number_schedul].run_end_time;
tasks[number_schedul].order=1;
temp_counter=1;
while（temp_counter{
for（j=0;j{
if（（tasks[j].come_time<=temp_time）&&（!
tasks[j].run_flag））
{
run_time=tasks[j].run_time;number_schedul=j;break;
}
}
for（j=0;j{
if（（tasks[j].come_time<=temp_time）&&（!
tasks[j].run_flag））
if（tasks[j].run_time{
run_time=tasks[j].run_time;
number_schedul=j;
}
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;
temp_time=tasks[number_schedul].run_end_time;
temp_counter++;//对找到的下一个被调度的进程求相应的参数
tasks[number_schedul].order=temp_counter;
}
return0;
}
3）HRRN算法
inthrrn（）//响应比高优先
{
intj,number_schedul,temp_counter;
floattemp_time,respond_rate,max_respond_rate;
//第一个进程被调度
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
//调度其他进程
while（temp_counter{
max_respond_rate=0;
for（j=1;j{
if（（tasks[j].come_time<=temp_time）&&（!
tasks[j].run_flag））
{
respond_rate=（temp_time-tasks[j].come_time）/tasks[j].run_time;
if（respond_rate>max_respond_rate）
{
max_respond_rate=respond_rate;
number_schedul=j;
}
}
}
//找响应比高的进程
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
temp_time=tasks[number_schedul].run_end_time;
tasks[number_schedul].run_flag=1;
temp_counter+=1;
tasks[number_schedul].order=temp_counter;
}
return0;
}
4）PS算法
intps（）//优先级调度
{
floattemp_time=0;
inti=0,j;
intnumber_schedul,temp_counter;
intmax_priority;
max_priority=tasks[i].priority;
j=1;
while（（j{//查找第一个被调度的进程
if（tasks[j].priority>tasks[i].priority）
{
max_priority=tasks[j].priority;
i=j;
}
j++;
}//查找第一个被调度的进程
//对第一个被调度的进程求相应的参数
number_schedul=i;
tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;//对第一个被调度的进程求相应的参数
temp_time=tasks[number_schedul].run_end_time;
tasks[number_schedul].order=1;
temp_counter=1;
while（temp_counter{
max_priority=0;
for（j=0;j{//查找下一个被调度的进程
if（（tasks[j].come_time<=temp_time）&&（!
tasks[j].run_flag））
if（tasks[j].priority>max_priority）
{
max_priority=tasks[j].priority;
number_schedul=j;
}
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;
temp_time=tasks[number_schedul].run_end_time;
temp_counter++;//对找到的下一个被调度的进程求相应的参数
tasks[number_schedul].order=temp_counter;
}
return0;
}
3.功能模块设计
intfcfs（）//先来先服务
intsjf（）//短作业优先
inthrrn（）//响应比高优先
intps（）//优先级调度
intpinput（）//进程参数输入
intpoutput（）//调度结果输出
voidmain（）//主函数
七、实验运行结果：
输入测试数据：
如上面两幅组图
功能菜单：
如下
选择1，使用先来先服务调度算法，结果运行如下
选择2，使用短作业优先调度算法，结果运行如下
选择3，使用响应比高优先调度算法，运行结果如下
选择4，使用优先级调度算法，运行结果如下
八、实验心得：
通过此次实验，我能够更加深入的理解各个进程调度算法以及他们的具体实现过程。
在实验过程中，我也遇到了一些困难，但是我通过及时请教同学，查询相关资料，及时解决了问题，但仍有不足之处，我将会在今后学习中更加努力。
功能二：
银行家算法
一、实验名称：
用C++实现银行家算法
二、实验目的：
通过自己编程来实现银行家算法，进一步理解银行家算法的概念及含义，提高对银行家算法的认识，同时提高自己的动手实践能力。
各种死锁防止方法能够阻止发生死锁，但必然会降低系统的并发性并导致低效的资源利用率。
死锁避免却与此相反，通过合适的资源分配算法确保不会出现进程循环等待链，从而避免死锁。
本实验旨在了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生。
三、实验内容：
利用C++,实现银行家算法
四、实验要求：
1.完成银行家算法的设计
2.设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
五、实验原理：
系统中的所有进程放入进程集合，在安全状态下系统收到进程的资源请求后，先把资源试探性的分配给它。
之后，系统将剩下的可用资源和进程集合中的其他进程还需要的资源数作比较，找出剩余资源能够满足的最大需求量的进程，从而保证进程运行完毕并归还全部资源。
这时，把这个进程从进程集合中删除，归还其所占用的所有资源，系统的剩余资源则更多，反复执行上述步骤。
最后，检查进程集合，若为空则表明本次申请可行，系统处于安全状态，可以真正执行本次分配，否则，本次资源分配暂不实施，让申请资源的进程等待。
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
为实现银行家算法，系统必须设置若干数据结构。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi（1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j安全状态：
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态：
不存在一个安全序列。
不安全状态不一定导致死锁。
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全，银行家规定：
（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；
（2）顾客可以分期贷款，但贷款的总数不能超过最大需求量；
（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；
（4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金.
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。
若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。
六、实验环境：
Win-7系统
VisualC++6.0
七、实验设计：
1.数据结构设计
定义结构体：
structProcess//进程属性构成
{
Sourceclaim;//进程最大需求量
Sourceallocation;//进程占有量
Sourceclaim_allocation;//进程需求量
SourcecurrentAvail;//进程可获得量
};
定义类对象：
classSource//资源的基本构成以及功能
{
private:
public:
intR1;//定义三类类资源
intR2;
intR3;
Source（intr1=0,intr2=0,intr3=0）
{R1=r1;R2=r2;R3=r3;}
Source（Source&s）
{R1=s.R1;R2=s.R2;R3=s.R3;}
voidsetSource（intr1=0,intr2=0,intr3=0）//设置各类资源
{R1=r1;R2=r2;R3=r3;}
voidadd（Sources）//加法
{R1=R1+s.R1;R2=R2+s.R2;R3=R3+s.R3;}
voidsub（Sources）//减法
{R1=R1-s.R1;R2=R2-s.R2;R3=R3-s.R3;}
boollower（Sources）//比较
{
if（R1>s.R1）returnfalse;
if（R2>s.R2）returnfalse;
if（R3>s.R3）returnfalse;
returntrue;
}
};
classData//封装所有数据
{
public:
Process*p;//进程指针
Sourcesum;//总资源量
Sourceavailable;//可获得量
Sourceask;//请求量
intpLength;//进程个数
int*ruler;//逻辑尺
voidclearProcess（）//进程currentAvail清零
{
for（inti=0;i{p[i].currentAvail.setSource（0,0,0）;}
}
};
classDataInit//封装初始化数据函数类
{
private:
public:
DataInit（）//构造函数
{}
voidinitLength（Data*db）//设置进程个数
{
intn;
cout<<"输入进程数:
";
cin>>n;
db->pLength=n;
db->p=newProcess[n];
if（!
db->p）
{cout<<"error!
noenoughmemoryspace！
";return;}
db->ruler=newint[n];
if（!
db->ruler）
{cout<<"error!
noenoughmemoryspace！
";return;}
}
2.算法设计
classFindSafeList//寻找安全序列
{
private:
public:
FindSafeList（）//构造函数
{}
boolcheckList（Data*db）//检查一个序列安全性
{
inti=0;//i用于循环
db->p[db->ruler[i]].currentAvail.add（db->available）;//将当前系统可用资源量赋给该序列的第一个进程
if（!
db->p[db->ruler[i]].claim_allocation.lower（db->p[db->ruler[i]].currentAvail））//若当前进程currentAvail小于该进程需求量（claim-allocation），返回false
{returnfalse;}
for（i=1;ipLength;i++）
{
//当前进程的可获得资源量currentAvail获得前一个进程的未释放资源前可获得资源量currentAvail
db->p[db->ruler[i]].currentAvail.add（db->p[db->ruler[i-1]].currentAvail）;
//当前进程的可获得资源量currentAvail获得前一个进程的释放的资源量
db->p[db->ruler[i]].currentAvail.add（db->p[db->ruler[i-1]].allocation）;
//若当前进程currentAvail小于该进程需求量（claim-allocation），返回false
if（!
db->p[db->ruler[i]].clai
升级会员 