操作系统实验 四种调度算法文档格式.docx

操作系统实验 四种调度算法文档格式.docx

《操作系统实验 四种调度算法文档格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验 四种调度算法文档格式.docx（15页珍藏版）》请在冰豆网上搜索。

floatexcellent;

intstart_time;

//开始时间

intwait_time;

//等待时间

intvisited;

//已读取次数

JOB（）

{

number=0;

reach_time=0;

reach_hour=0;

reach_minite=0;

need_time=0;

privilege=0;

excellent=0.0;

start_time=0;

wait_time=0;

visited=0;

}

JOB&

Copy（JOBjs[]）

inti=0;

while（js[i].number&

&

js[i].number>

0）

{

i++;

}

JOB*js2=newJOB[i];

for（intj=0;

j<

i;

j++）

js2[j].number=js[j].number;

js2[j].reach_time=js[j].reach_time;

js2[j].reach_hour=js[j].reach_hour;

js2[j].reach_minite=js[j].reach_minite;

js2[j].need_time=js[j].need_time;

js2[j].privilege=js[j].privilege;

js2[j].excellent=js[j].excellent;

js2[j].start_time=js[j].start_time;

js2[j].wait_time=js[j].wait_time;

return*js2;

};

//FIFO算法

voidFIFO（JOBjob[],intquantity）

{

JOB*jobs;

jobs=（&

jobs->

Copy（job））;

intcurrent_hour;

intcurrent_minute;

inttotal_time=0;

//输出作业流

cout<

<

endl;

endl<

"

FIFO调度算法：

cout.setf

（2）;

setw（10）<

作业号：

setw（12）

<

到达时间：

setw（12）<

开始时间：

setw（14）<

周转时间（分）：

current_hour=jobs[0].reach_hour;

current_minute=jobs[0].reach_minite;

for（inti=0;

i<

quantity;

i++）

{

jobs[i].start_time=current_hour*100+current_minute;

jobs[i].wait_time=（current_hour-jobs[i].reach_hour）

*60+（current_minute-jobs[i].reach_minite）+jobs[i].need_time;

cout<

jobs[i].number<

<

jobs[i].reach_time<

jobs[i].start_time<

setw（14）

jobs[i].wait_time<

current_hour=current_hour+（jobs[i].need_time+current_minute）/60;

current_minute=（jobs[i].need_time+current_minute）%60;

total_time+=jobs[i].wait_time;

}

总周转时间:

total_time<

平均周转时间:

total_time/quantity<

}

//运算时间短的作业优先算法

voidShorter（JOBjob[],intquantity）

inti,j,p;

intcurrent_need_time;

时间短作业优先算法:

作业号:

到达时间:

所需时间（分）:

开始时间:

周转时间（分）:

current_hour=jobs[quantity-1].reach_hour;

current_minute=jobs[quantity-1].reach_minite;

for（i=0;

i++）{

current_need_time=30000;

for（j=0;

j++）{

if（（jobs[j].visited==0）&

（jobs[j].need_time<

current_need_time））{

p=j;

current_need_time=jobs[j].need_time;

}

}

jobs[p].start_time=current_hour*100+current_minute;

jobs[p].wait_time=（current_hour-jobs[p].reach_hour）

*60+（current_minute-jobs[p].reach_minite）+jobs[p].need_time;

jobs[p].number<

jobs[p].reach_time<

jobs[p].need_time

jobs[p].start_time<

jobs[p].wait_time<

current_hour=current_hour+（jobs[p].need_time+current_minute）/60;

current_minute=（jobs[p].need_time+current_minute）%60;

jobs[p].visited=1;

total_time+=jobs[p].wait_time;

//优先数调度算法

voidPrivilege（JOBjob[],intquantity）

intcurrent_privilege;

优先数调度算法:

优先级:

（0>

1）:

current_privilege=30000;

（jobs[j].privilege<

current_privilege））{

current_privilege=jobs[j].privilege;

jobs[p].privilege

//响应比最高者优先调度算法

voidExcellent（JOBjob[],intquantity）

floatcurrent_excellent;

响应比高者优先调度算法:

作业号"

到达时间"

开始时间"

周转时间（分）"

current_excellent=-1;

if（jobs[j].visited==0）{

jobs[j].wait_time=（current_hour-jobs[j].reach_hour）*60+（current_minute-jobs[j].reach_minite）;

jobs[j].excellent=（float）（jobs[j].wait_time/jobs[j].need_time）;

（jobs[j].excellent>

current_excellent））{

current_excellent=jobs[j].excellent;

jobs[p].wait_time=（current_hour-jobs[p].reach_hour）*60+（current_minute-jobs[p].reach_minite）+jobs[p

].need_time;

jobs[p].number

jobs[p].reach_time

jobs[p].start_time

intmain（void）

**********************调度模拟**************************\n\n\n"

intquantity=0;

//数量

JOBjobs[MAXJOB];

请输入作业数据文件名:

\n"

;

FILE*fp;

charfname[20];

cin>

>

fname;

fp=fopen（fname,"

r"

）;

//以只读方式打开文件

if（!

fp）

打开文件错误！

）"

else

while（!

feof（fp））

{

fscanf（fp,"

%d%d%d%d"

&

jobs[quantity].number,

jobs[quantity].reach_time,

jobs[quantity].need_time,

jobs[quantity].privilege）;

jobs[quantity].reach_hour=jobs[quantity].reach_time/100;

jobs[quantity].reach_minite=jobs[quantity].reach_time%100;

quantity++;

//输出初始作业数据

初始作业数据：

cout.setf

（2）;

所需时间（分）：

优先级：

1）"

for（inti=0;

cout<

jobs[i].number

<

jobs[i].reach_time

jobs[i].need_time

jobs[i].privilege<

lb:

请选择调度算法:

\t\t1---先进先出调度算法\n"

\t\t2---短作业优先\n"

\t\t3---优先级调度算法\n"

\t\t4---响应比最高调度算法"

intflag=0;

la:

flag;

switch（flag）

case1:

FIFO（jobs,quantity）;

break;

//先进先出调度算法

case2:

Shorter（jobs,quantity）;

break;

//短作业优先

case3:

Privilege（jobs,quantity）;

//优先级调度算法

case4:

Excellent（jobs,quantity）;

//响应比最高调度算法

default:

cout<

请输入1-4之间的数"

gotolb;

gotola;

return0;

}

数据文件：

data.txt

1700401

2723322

3821253

4823214

5900156

6912104

7930515

总结及程序简介：

1．首先将数据存在data.txt文件中，在主函数中读入数据存入数组jobs[]中

2．定义类JOB包含

属性：

intnumber;

intreach_minite;

方法:

构造函数JOB（）

复制函数Copy（）实现一个对象

2．分别实现调度算法，然后在主函数中依次调用

调试结果：