操作系统作业调度实验报告 多道批处理Word文档格式.docx

操作系统作业调度实验报告 多道批处理Word文档格式.docx

《操作系统作业调度实验报告 多道批处理Word文档格式.docx》由会员分享，可在线阅读，更多相关《操作系统作业调度实验报告 多道批处理Word文档格式.docx（32页珍藏版）》请在冰豆网上搜索。

ttime/p->

ntime作业的平均带权周转时间：

W=全部进程的带权周转时间/进程个数

1先来先服务调度算法（FCFS）:

每次调度都是从后备作业队列中，选择一个或多个最先

进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，这每次调度是从就绪队列中，选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件阻赛后，才放弃处理机。

2、最短作业优先（SJF）：

每次从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。

3、多道作业调度算法：

将作业按FCFS原则排好队，在输入井中按作业到达的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业，把不能满足要求的放回输入井尾部等待，当作业执行结束进入完成状态时，做好释放资源等善后工作。

四、流程图

1FCFS算法和SJF算法：

计算并打印运行作业P的完成时间ftime,周转时间ttime,带权周转时间wtime

（ftime=btime+ntime;

ttime=ftime-atime;

wtime=ttime/ntime）

更改时间量T的值（T=ftime）

继续执行该进程

（p->

rtime）++

撤销进程，指向下一进程

2.多道作业调度算法

五、给出程序中源程序名和执行程序名：

源程序名：

FCFSandSJF,执行程序名：

fcfsandsjf.cpp源程序名：

DUODAO执行程序名：

duodao.cpp六、程序清单

1.FCFS和SJF算法

#include"

stdio.h"

#include<

stdlib.h>

conio.h>

#definegetpch（type）（type*）malloc（sizeof（type））

structjcb{

charname[10];

charstate;

intatime;

//作业到达时间

intbtime;

//作业开始运行时间

intftime;

//作业完成时间

intntime;

//作业估计运行时间

intrtime;

//作业执行时间

intttime;

//周转时间

floatwtime;

//带权周转时间（周转时间/估计运行时间）

structjcb*link;

}*ready=NULL,*p;

//ready指向队头，p指向正被调度的作业

typedefstructjcbJCB;

intT=0;

//初始化时间量

floattotal;

//记录所有作业的总时间

doubleweight;

//记录所有作业的带权周转时间

voidsort（）/*建立对作业进行到达时间排列函数*/

{

JCB*first,*second;

intinsert=0;

if（（ready==NULL）||（（p->

atime）<

（ready->

atime）））/*作业到达时间最短的,插入队首*/{

p->

link=ready;

ready=p;

T=p->

atime;

//更改时间量

}

else/*作业比较到达时间,插入适当的位置中*/

first=ready;

second=first->

link;

while（second!

=NULL）

{if（（p->

（second->

atime））/*若插入作业比当前队尾作业到达时间短,*/{/*插入到当前队尾作业前面*/

link=second;

first->

link=p;

second=NULL;

insert=1;

else/*插入作业到达时间最长,则插入到队尾*/

first=first->

second=second->

if（insert==0）first->

voidshortjob（）//获取队列中的最短作业

JCB*pr,*min,*qr;

min=ready;

//min指向作业对头

qr=ready;

pr=ready->

while（pr!

{if（（pr!

=NULL）&

&

（T>

=pr->

atime）&

（pr->

ntime）<

（min->

ntime））

{//当插入作业到达时间要比时间量T小

min=pr;

//min指向prqr->

link=pr->

//qr的下一个指向pr的下一个pr->

pr=pr->

else//当pr的需要时间不小于min的需要时间

{qr=pr;

pr=pr->

ready=min;

〃把最终获取的min的需要时间赋给ready,开始执行

voidinput（）/*建立作业控制块函数*/

inti;

printf（"

\n请输入4个作业：

"

）;

for（i=0;

i<

4;

i++）

\n请输入作业号NO.%d：

\n"

i）;

p=getpch（JCB）;

printf（"

输入作业名：

scanf（"

%s"

p->

name）;

\n输入作业到达时间：

scanf（"

%d"

&

atime）;

\n输入作业运行时间：

ntime）;

\n"

rtime=0;

btime=0;

ftime=0;

ttime=0;

wtime=0;

state='

W'

;

link=NULL;

sort（）;

intspace（）/*查看作业个数*/

intl=0;

JCB*pr=ready;

while（pr!

=NULL）

l++;

pr=pr->

return（l）;

voiddisp（JCB*pr）/*建立作业显示函数，用于显示当前作业*/

\nqname\tstate\tatime\tntime\tbtime\trtime\tftime\tttime\twtime\n"

|%s\t"

pr->

|%c\t"

state）;

|%d\t"

btime）;

rtime）;

ftime）;

ttime）;

|%.2f\t"

wtime）;

voidcheck（）/*建立作业查看函数*/

JCB*pr;

\n****当前正在运行的作业是:

/*显示当前运行作业*/disp（p）;

pr=ready;

\n****当前就绪队列状态为:

/*显示就绪队列状态*/while（pr!

disp（pr）;

voiddestroy（）

\n作业[%s]已完成。

free（p）;

voidrunning（JCB*pr）//计算各个时间

if（T>

atime）pr->

btime=T;

//插入作业的到达时间比时间量小，T为该作业的开始时间elsepr->

btime=pr->

//否则该作业到达时间为它的开始时间pr->

ftime=pr->

btime+pr->

ntime;

pr->

pr->

wtime=（float）pr->

ttime/（float）pr->

total+=pr->

ttime;

weight+=pr->

wtime;

T=pr->

ftime;

//T为该上一个作业的完成时间

voidrunning1（JCB*pr）//分离出要执行的当前作业

elsepr->

voidrunning2（JCB*pr）//判断运行时间和需要运行时间的关系

while（pr->

rtime<

ntime）

R'

rtime）=（pr->

\n\n****该作业执行完毕时的状态：

state='

F'

destroy（）;

intmain（）

inti,len,h=0;

charch;

total=0;

weight=0;

printf（

2.多道作业调度算法：

#include"

#include<

#definesource15structjcb{

charusername[10];

charjobname[10];

//作业的运行时间

intnsource;

//作业所需系统资源

intasource;

//已分配的资源

intneed1;

//ready指向就绪队列的队头，p指向正被调度的作业typedefstructjcbJCB;

intrsource=15;

//剩下资源

intnum,i=0;

//num为作业个数，i为记录不能满足作业要求调度的次数voiddestroy（JCB*pr）

free（pr）;

if（（p->

nsource<

=source）&

（rsource>

=0）&

nsource>

asource））

{//需要资源要在系统资源范围内，分配资源要在需要资源范围内，剩下资源不能小于0if（（ready==NULL）||（（p->

ready=p;

{first=ready;

atime））/*若插入作业比当前队尾作业到达时间短,*/{/*插入到当前队尾作业前面*/p->

insert=1;

{first=first->

elsedestroy（p）;

voidsort1（）/*对作业进行排列函数*/

JCB*first;

if（ready==NULL）/*如果就绪队列为空*/

/*将新建作业放入队列中，将ready指向队首作业*/

else/*队列中有作业在等待，将新建作业插入到队尾*/

/*first指针指向队首作业*/

while（first->

link!

=NULL）first=first->

/*当first指针没有指向队尾时，指针后移*/

first->

/*将p指向的作业插入队尾*/

\n请输入作业个数:

"

num）;

for（i=0;

i<

num;

i++）

输入作业用户名:

username）;

\n输入作业名:

jobname）;

\n输入作业到达时间:

\n输入作业运行时间:

\n输入作业所需资源:

nsource）;

\n输入作业已分配资源:

asource）;

need1=p->

nsource-p->

asource;

//还需要资源=需要资源-已分配资源p->

link=NULL;

sort（）;

intl=0;

JCB*pr=ready;

\n用户N\t作业N\t状态S\t到达T\t服务T\t所需S\t已分S\t还需S\n"

need1）;

voidcheck（）

JCB*pr;

\n****当前正在运行的作业是：

%s"

disp（p）;

\n****当前输入井队列状态为：

/*显示就绪队列状态*/

voidrunning（JCB*p）//对输入井队列中满足资源要求的作业进行服务

while（p->

{（p->

rtime）++;

\n****作业运行完成后状态:

\n用户名[%s]的作业[%s]已完成。

username,p->

voidrunning1（）//计算剩下资源

for（pr=ready;

pr!

=NULL;

link）{rsource=rsource-pr->

voidrunning2（JCB*pr）

if（pr->

need1<

=rsource）

check（）;

rsource-=pr->

need1;

asource+=pr->

need1=0;

\t*******************************************printf（"

\n分配给作业后所剩的资源是：

%d\n"

rsource）;

running（pr）;

rsource=rsource+pr->

nsource;

\n释放后的资源是：

%d\n"

destroy（pr）;

else

该作业不能满足要求，调度下一个作业"

sort1（）;

i++;

voidmain（）

intlen,h=0;

//h表示执行的次数

intflag=0;

//用来记录排在前面却没被调用的作业个数charch;

printf（"

********************************************************

多道作业调度算法

input（）;

len=space（）;

running1（）;

if（rsource>

=0）

while（（i<

=2*num）&

（len!

（ready!

=NULL））

ch=getchar（）;

h++;

printf（"

Theexecuenumber:

%d\n"

h）;

\n系统可分配资源是：

％d"

ch=getchar（）;

p=ready;

ready=ready->

link;

link=NULL;

state='

running2（p）;

\n按任一键继续..."

if（i>

2）

\n******剩下系统资源不能满足作业需要要求了\n”）;

\n******退出程序"

elseprintf（"

\n作业已完成\n"

\n\n****因为输入已分配的资源与系统资源不符合错误，所以退出程序

七、运行结果

［厂4.

E#ho.bi

输入作业运行时间:

12

输入作业到达时间：

6

输人作业运顾2

输入作业运行时间：

is

1.FCFS算法

絲爨:

1

Tlieexecuteruuwnhei*-1

一*当前正在运行的作业是述

qnamestAteatime

ntime

btime

i*time

ftime

ttime

wtime

:

C!

R12

****当刖就绪队列状态为=

：

\2

16

0.S0

qnamestateati（ne