操作系统实验报告3篇

课程设计说明书

设计题目：操作系统课程设计

班级：信息管理与信息系统2011级

学号：

姓名：

山东科技大学

2013年12 月25 日

课程设计任务书

学院信息科学与工程专业信息学管理与信息系统班级2011-1

姓名

一、课程设计题目：操作系统课程设计

二、课程设计主要参考资料

（1）Abraham Silberschatz & Peter Baer Galvin & Greg Gagne. Operating System Concepts（第七版影印版）. 高等教育出版社. 2007.3.

（2）计算机操作系统（第三版）西安电子科技大学出版社

（3）

三、课程设计应解决的主要问题：

（1）CPU调度算法的模拟实现

（2）死锁相关算法的实现

（3）磁盘调度算法的实现

四、课程设计相关附件（如：图纸、软件等）：

（1）程序源代码

（2）

五、任务发出日期：2013-10-1 课程设计完成日期：2014-1-1

指导教师签字：

指导教师对课程设计的评语成绩：

指导教师签字：

年月日

设计1 CPU调度算法的模拟实现

一、设计目的

1、根据系统的资源分配策略所规定的资源分配算法

2、利用编程语言，模拟实现先来先服务（FCFS）、最短作业优先（非抢占SJF）、非抢占优先调度算法、时间片轮转调度算法（RR）

3、针对模拟进程，利用CPU调度算法进行调度

4、进行算法评价，计算平均周转时间和平均等待时间

二、设计要求

1、调度所需的进程参数由输入产生（手工输入或者随机数产生）

2、输出调度结果

3、输出算法评价指标

三、设计说明

1、定义public类：

class program{

public:

char name;//进程名

int atime;//进程到达的时间

int stime;//进程服务的时间

int btime;//进程开始执行的时间

int ftime;//进程完成的时间

int rtime;//进程的周转时间

float qrtime;//进程的带权周转时间

};

2、冒泡排序：

class program t;

for( i=1;i

for(int j=0;j

if(p[j].atime>p[j+1].atime){

t=p[j];

p[j]=p[j+1];

p[j+1]=t;

}

3、流程图：

（1）①先来先服务调度流程图：

②主要程序

p[0].btime=p[0].atime;

p[0].ftime=p[0].atime+p[0].stime;

p[0].rtime=p[0].ftime-p[0].atime;

p[0].qrtime=(float)p[0].rtime/p[0].stime;

for(i=1;i

if(p[i].atime>p[i-1].ftime){

p[i].btime=p[i].atime;

}

else{

p[i].btime=p[i-1].ftime;

}

p[i].ftime=p[i].btime+p[i].stime;

p[i].rtime=p[i].ftime-p[i].atime;

p[i].qrtime=(float)p[i].rtime/p[i].stime;

}

①短作业优先进程(非抢占优先权)调度流程图：

②（ＳＪＦ）主要代码

int k=0,x=0;

for(i=k+1;i

for(j=k+1;j

if(p[j].atime

x++;

}

else

break;

}

int min=k+1;

if(x>1){

for(j=k+2;j<=x+k;j++){

if(p[j].stime

min=j;

}

}

t=p[min];

p[min]=p[k+1];

p[k+1]=t;

p[k+1].ftime=p[k].stime+p[k+1].stime;

}

k++;

x=0;

}

③优先权调度算法（非抢占）：

int k=0,x=0;

for(i=k+1;i

for(j=k+1;j

if(p[j].atime

x++;

}

else

break;

}

int min=k+1;

if(x>1){

for(j=k+2;j<=x+k;j++){

if(p[j].youxianquan

min=j;

}

}

t=p[min];

p[min]=p[k+1];

p[k+1]=t;

p[k+1].ftime=p[k].stime+p[k+1].stime;

}

k++;

x=0;

}

①时间片轮转调度算法：

②主要算法

int time=p[0].atime;

int Max=p[0].stime1;

for(i=0; i

{

p[i].stime2=p[i].stime1;

if(p[i].stime1>Max)

Max=p[i].stime1; }

for(int j=0; j

{

for(i=0; i

{

if(p[i].stime2==0)

continue;

if(p[i].atime<=time)

{

p[i].stime2-=1;

time+=1;

}

else

i=-1;

if(p[i].stime2==0)

p[i].ftime=time;

}

}

4、输出

p[0].btime=p[0].atime;

p[0].ftime=p[0].atime+p[0].stime;

p[0].rtime=p[0].ftime-p[0].atime;

p[0].qrtime=(double)p[0].rtime/p[0].stime;

for(i=1;i

if(p[i].atime>p[i-1].ftime){

p[i].btime=p[i].atime;

}

else{

p[i].btime=p[i-1].ftime;

}

p[i].ftime=p[i].btime+p[i].stime;

p[i].rtime=p[i].ftime-p[i].atime;

p[i].qrtime=(float)p[i].rtime/p[i].stime;

}

cout<<"进程******到达时间**服务时间**开始执行时间*完成时间**周转时间**带权周转时间"<

for(i=0;i

{

cout<

}

}

四、运行结果及分析

1、先来先服务（FCFS）测试数据

2、短作业优先（SJF）测试数据

3、优先权（非抢占）测试数据

4、时间片轮转（RR）测试数据

五、总结

通过这次试验，我进一步的理解了冒泡排序的算法，而且，对进程作业先来先服务、短进程优先、非抢占优先、按时间片轮转调度算法以及进程调度的概念和算法，有了更深入的认识！初步理解了操作系统对于作业处理的基本思想！了解到算法很重要，又更加明白算法本身可以节约时间。在动手操作过程中，体会到了成功的喜悦；遇到问题自己解决的能力，对于我来说是一次提高，让自己多多的在实践中可以加深对理论的理解，也让我明白了以后应该如何更好，更高效的学习。

设计2 死锁相关算法的实现

一、设计目的

银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

二、设计要求

1、编写算法，实现银行家算法、安全性算法、死锁检测算法

2、判断系统安全状态、判断进程的资源请求是否可以被满足、判定系统是否为死锁状态

三、设计说明

1、数据结构：

（1）可利用资源向量Available。这是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果

Available[j]=K，则表示系统中现有Rj类资源K个。

（2）最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i，j]=K，则表示进程i需要Rj类资源的最大数目为K。

（3）分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i，j]=K，则表示进程i当前已分得Rj类资源的数目为K。

（4）需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i，j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

Need[i，j]=Max[i，j]-Allocation[i，j]

系统流程图

2、银行家算法步骤：

（1）如果Request i[j] <=Need[i，j]，则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request i[j] <=Available[j]，则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi，并修改下面数据结构中的数值：Available[j]:=Available[j]- Request i[j]；

Allocation[I,j]=Allocation[i,j]+ Request i[j]；

Need[i,j]=Need[I,j]- Request i[j]；

(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法：

（1）设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work:=Available；

②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]:=true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i]=false；

②Need=Work；如找到，执行步骤（3）；否则，执行步骤（4）。（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work=Work+Allocation；

Finish[i]=true；

转向步骤（2）。

（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

银行家算法流程图

安全性算法流程图

主要代码

1、头文件：

#include

#include

#define False 0

#define True 1

using namespace std;

char name[50]={0};

int Max[50][50]={0};

int Allocation[50][50]={0};

int Need[50][50]={0};

int Available[50]={0};

int Request[50]={0};

int Work[50]={0};

int Finish[50]={0};

int temp[50]={0};

int b[50]={0};

int M=50;

int N=50;

2、显示资源矩阵

void display()

{

int i,j,number,m,n;

char Name;

int a[50]={0};

cout<<"请输入系统中资源的种类:";

cin>>n;

N=n;

for(i=0;i

{

cout<<"资源"<

cin>>Name>>number;

name[i]=Name;

b[i]=number;

}

cout<<"请输入进程的数量:";

cin>>m;

M=m;

cout<<"请输入各进程的最大需求[Max]:"<

for(i=0;i

for(j=0;j

cin>>Max[i][j];

cout<<"请输入各进程的已分配[Allocation]:"<

for(i=0;i

for(j=0;j

{

cin>>Allocation[i][j];

Need[i][j]=Max[i][j]-Allocation[i][j];

if(Need[i][j]<0)

{

cout<<"您输入的第"<

j--;

continue;

}

}

cout<<"目前可用的资源:"<

for(i=0;i

cout<

cout<

for (j=0;j

{

for(i=0;i

{

a[j]+=Allocation[i][j];

}

Available[j]=b[j]-a[j];

}

for(i=0;i

cout<

cout<

}

3、矩阵的输出

void print()

{

int i,j;

cout<<" Max Allocation Need"<

cout<<"进程名";

for(j=0;j<3;j++)

{

for(i=0;i

cout<

cout<<" ";

}

cout<

for(i=0;i

{

cout<<" "<

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<

}

}

4、进行资源分配

int changdata(int i)

{

int j;

for (j=0;j

{

Available[j]=Available[j]-Request[j];

Allocation[i][j]=Allocation[i][j]+Request[j];

Need[i][j]=Need[i][j]-Request[j];

}

return 1;

}