操作系统进程调度算法模拟c++实验报告.docx

操作系统进程调度算法模拟c++实验报告.docx

《操作系统进程调度算法模拟c++实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统进程调度算法模拟c++实验报告.docx（18页珍藏版）》请在冰豆网上搜索。

操作系统进程调度算法模拟c++实验报告

南通大学计算机科学与技术学院

操作系统课程设计

报告书

设计题目模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法

专业班级计xxx

学生姓名xxxxx

学号161xxxxxxxx

日期2018.01.8-2018.01.12

课程设计题目：

模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法

一、主要目的

模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法

二、设备与环境

1.硬件设备：

PC机一台

2.软件环境：

Windows操作系统，vc6.0

三、实验要求

1.实验题目

模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法

2.数据结构及主要符号说明。

用两个数组分别表示进程的运行时间和优先级，数组大小定义为100，用以适应多种进程算法计算

在各个算法模块函数中，所有的符号都是采用了同一种浮点型变量符号（如下所示）；

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

特殊的：

在所有算法里出现的“i”“j”均表示计数，

在功能函数编写过程中，参数均是以a，b，c代替的其中c表示固定输入的进程数量，用以作为函数中循环跳出的标志；

在时间片轮转算法中，用time表示时间片的大小，用m表示尚未完成的进程数；

在时间片轮转算法中，定义了新的数组d[100]，用来保存相应的进程运行时间在循环过程中用以操作，避免因操作过程中数值变化无法进行后续操作

四、程序流程图和源程序

先来先服务算法源程序及流程图

voidFirst（floata[],intc）//先来先服务算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti;//计数

for（i=1;i<=c;i++）//先来先服务算法具体实现

{

r+=a[i];//每个进程周转时间

s=r/a[i];//每个进程加权周转时间

t+=r;//总周转时间

S+=s;//总加权周转时间

}

T=（float）t/c;//计算平均周转时间

W=（float）S/c;//计算平均加权周转时间

/****************输出******************/

cout<<"先来先服务算法平均周转时间：

"<

cout<<"先来先服务算法平均带权周转时间:

"<

}

短作业优先算法计流程图

voidShort（floata[],intc）//短作业优先算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

intb[100];

inti,j;//计数

for（i=1;i<=c;i++）

b[i]=a[i];

for（i=1;i

{

for（j=1;j<=c-i;j++）

if（b[j]>=b[j+1]）

{

floatm=b[j];

b[j]=b[j+1];

b[j+1]=m;

}

}

for（i=1;i<=c;i++）//根据排序顺序实行短作业优先算法

{

r+=b[i];

s=（float）r/b[i];

t+=r;

S+=s;

}

/*平均周转时间及平均加权周转时间计算*/

T=（float）t/c;

W=（float）S/c;

/*************计算结果输出************/

cout<<"短作业优先算法平均周转时间：

"<

cout<<"短作业优先算法平均带权周转时间:

"<

}

时间片轮转算法源程序及流程图

voidTime（floata[],intc）//时间片轮转算法

{

floattime=1;//规定时间片的大小

floatt=0;//保存周转时间和

floatT;//用于保存平均周转时间

floatr=0;//保存各进程周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti;//计数

intm=c;//用于判定循环结束标准

floatd[100];

for（i=1;i<=c;i++）//将待运行进程时间存入新的数组当中，便于之后的运算

d[i]=a[i];

cout<<"时间片轮转算法进程运行次序：

";

while（m>0）//时间片轮转，当所有进程执行完毕以后跳出

{

for（i=1;i<=c;i++）//每一个单次循环，每一个未完成进程分配一次时间片

{

if（d[i]>0）//进程完成与否的判断

{

cout<

r+=1;

d[i]-=1;

if（d[i]<=0）//进程若执行完毕，周转时间得出，加权周转时间得出，总时间得出

{

m--;

s=r/a[i];

S+=s;

t+=r;

}

}

}

}

cout<

/***计算平均周转时间，平均加权周转时间***/

T=t/c;

W=S/c;

/*********计算结果输出*********/

cout<<"时间片轮转算法平均周转时间：

"<

cout<<"时间片轮转算法平均带权周转时间:

"<

}

优先级调度算法源程序及流程图

voidPrecedence（floata[],floatb[],intc）//优先级调度算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti,j;//计数

for（i=1;i<=c;i++）//根据优先级确定进程执行顺序（冒泡排序）

{

for（j=1;j<=c-i;j++）

if（a[j]

{

floatm=a[j];

a[j]=a[j+1];

a[j+1]=m;

floatn=b[j];

b[j]=b[j+1];

b[j+1]=n;

}

}

for（i=1;i<=c;i++）

{

r+=b[i];

s=（float）r/b[i];

t+=r;

S+=s;

}

/*******计算及结果输出********/

T=（float）t/c;

W=（float）S/c;

cout<<"优先级调度算法平均周转时间：

"<

cout<<"优先级调度算法平均带权周转时间:

"<

}

主函数源程序

intmain（）//主函数

{

inti;//计数确定进程到来次序

intn;//保存进程数量

floatOperation[100],Priority[100];//用于保存各个进程运行时间及优先级

cout<<"请输入进程数：

";

cin>>n;

cout<<"请依次输入各个进程运行时间及优先级:

";

for（i=1;i<=n;i++）

cin>>Operation[i]>>Priority[i];

system（"cls"）;//清屏

/*********按表格显示进程参数*********/

cout<<"输入进程运行时间及优先级如下：

"<

cout<<"进程号"<<'\t'<<"执行时间"<<'\t'<<"优先级"<<'\n';

for（i=1;i<=n;i++）

cout<<"job"<

/*********调用函数********/

First（Operation,n）;

cout<

Short（Operation,n）;

cout<

Time（Operation,n）;

cout<

Precedence（Priority,Operation,n）;

return0;

}

五、程序运行结果截图

六、收获以及心得体会

经过这次程序编写过程，我比较深刻的了解到了进程调度算法的具体实现思想，在编程过程中我发现，假使我在编写一个操作系统时，编写一段代码，绝对不能仅仅以实现某个具体的实验目标作为编程的最终结果，而不考虑这一点很可能会造成后续程序的混乱，数据的流失与改变。

这一次的课程设计任务，我仅仅是用了模块化的程序设计，并没有使用类，很大程度上影响了系统的安全性，在进行后续排序过程中，使用了并不稳定的排序方法，使得整个程序的输出结果出现了不稳定性，这也是操作系统中所并不能允许的事情。

七、附录源程序（可运行调试）

#include

usingnamespacestd;

voidFirst（floata[],intc）//先来先服务算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti;//计数

for（i=1;i<=c;i++）//先来先服务算法具体实现

{

r+=a[i];//每个进程周转时间

s=r/a[i];//每个进程加权周转时间

t+=r;//总周转时间

S+=s;//总加权周转时间

}

T=（float）t/c;//计算平均周转时间

W=（float）S/c;//计算平均加权周转时间

/****************输出******************/

cout<<"先来先服务算法平均周转时间：

"<

cout<<"先来先服务算法平均带权周转时间:

"<

}

voidShort（floata[],intc）//短作业优先算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

intb[100];

inti,j;//计数

for（i=1;i<=c;i++）

b[i]=a[i];

for（i=1;i

{

for（j=1;j<=c-i;j++）

if（b[j]>=b[j+1]）

{

floatm=b[j];

b[j]=b[j+1];

b[j+1]=m;

}

}

for（i=1;i<=c;i++）//根据排序顺序实行短作业优先算法

{

r+=b[i];

s=（float）r/b[i];

t+=r;

S+=s;

}

/*平均周转时间及平均加权周转时间计算*/

T=（float）t/c;

W=（float）S/c;

/*************计算结果输出************/

cout<<"短作业优先算法平均周转时间：

"<

cout<<"短作业优先算法平均带权周转时间:

"<

}

voidTime（floata[],intc）//时间片轮转算法

{

floattime=1;//规定时间片的大小

floatt=0;//保存周转时间和

floatT;//用于保存平均周转时间

floatr=0;//保存各进程周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti;//计数

intm=c;//用于判定循环结束标准

floatd[100];

for（i=1;i<=c;i++）//将待运行进程时间存入新的数组当中，便于之后的运算

d[i]=a[i];

while（m>0）//时间片轮转，当所有进程执行完毕以后跳出

{

for（i=1;i<=c;i++）//每一个单次循环，每一个未完成进程分配一次时间片

{

if（d[i]>0）//进程完成与否的判断

{

r+=1;

d[i]-=1;

if（d[i]<=0）//进程若执行完毕，周转时间得出，加权周转时间得出，总时间得出

{

m--;

s=r/a[i];

S+=s;

t+=r;

}

}

}

}

cout<

/***计算平均周转时间，平均加权周转时间***/

T=t/c;

W=S/c;

/*********计算结果输出*********/

cout<<"时间片轮转算法平均周转时间：

"<

cout<<"时间片轮转算法平均带权周转时间:

"<

}

voidPrecedence（floata[],floatb[],intc）//优先级调度算法

{

floatt=0;//保存周转时间和

floatr=0;//保存各进程周转时间

floatT;//用于保存平均周转时间

floatS=0;//用于保存带权周转时间和

floats;//用于保存各程序带权周转时间

floatW;//用于保存平均带权周转时间

inti,j;//计数

for（i=1;i<=c;i++）//根据优先级确定进程执行顺序（冒泡排序）

{

for（j=1;j<=c-i;j++）

if（a[j]

{

floatm=a[j];

a[j]=a[j+1];

a[j+1]=m;

floatn=b[j];

b[j]=b[j+1];

b[j+1]=n;

}

}

for（i=1;i<=c;i++）

{

r+=b[i];

s=（float）r/b[i];

t+=r;

S+=s;

}

/*******计算及结果输出********/

T=（float）t/c;

W=（float）S/c;

cout<<"优先级调度算法平均周转时间：

"<

cout<<"优先级调度算法平均带权周转时间:

"<

}

intmain（）//主函数

{

inti;//计数确定进程到来次序

intn;//保存进程数量

floatOperation[100],Priority[100];//用于保存各个进程运行时间及优先级

cout<<"请输入进程数：

";

cin>>n;

cout<<"请依次输入各个进程运行时间及优先级:

";

for（i=1;i<=n;i++）

cin>>Operation[i]>>Priority[i];

system（"cls"）;//清屏

/*********按表格显示进程参数*********/

cout<<"输入进程运行时间及优先级如下：

"<

cout<<"进程号"<<'\t'<<"执行时间"<<'\t'<<"优先级"<<'\n';

for（i=1;i<=n;i++）

cout<<"job"<

/*********调用函数********/

First（Operation,n）;

cout<

Short（Operation,n）;

cout<

Time（Operation,n）;

cout<

Precedence（Priority,Operation,n）;

return0;

}