进程调度实验设计报告.docx

进程调度实验设计报告.docx

《进程调度实验设计报告.docx》由会员分享，可在线阅读，更多相关《进程调度实验设计报告.docx（25页珍藏版）》请在冰点文库上搜索。

进程调度实验设计报告

实验2进程调度

姓名：

xxxxx

班级：

xxxxxxxx学号：

xxxxxxxxxxxxxxxxxxxxxxx上级日期：

2018年10月成绩:

实验目的:

1、通过对进程调度算法的设计、编写以及运行，深入理解进程调度的基本概念和基本调度算法;

2、利用C语言实现掌握进程算法（优先级调度算法、时间片轮转调度算法），比较几种算法的优劣;

3、理解有关进程控制块、进程队列的概念，掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑;

二、实验内容1、流程设计图:

1-轮转训俭前池

，-hM

TT7i*l

3.辭-:

^開,先鋼辱法

就绪

2、调度算法源代码:

1.

#include

2.

#include

3.

#include

4.

typedefstruct

node

5.

{

6.

charname[20];

/*进程的名字*/

7.

intprio;/*

进程的优先级*/

8.

intround;/*

分配CPU的时间片*/

9.

intcputime;

/*CPU执行时间*/

10.

intneedtime;

/*进程执行所需要的时间*/

11.

charstate;

/*进程的状态，W--就绪态,

Jl2.

intcount;/*

记录执行的次数*/

R--执行态，F--完成态*/

13.

structnode*next;

/*链表指针*/

14.

}PCB;

15.

PCB*ready=NULL,*run=NULL,*finish=NULL;

队列*/

/*定义三个队列，就绪队列，执行队列和完成

16.

intnum;

17.

void

GetFirst（）;

/*

从就绪队列取得第一个节点*/

18.

void

Output（）;

/*

输出队列信息*/

19.

void

InsertPrio（PCB*in）;

20.

void

InsertTime（PCB*in）;

/*创建优先级队列，规定优先数越小，优先级越高

/*时间片队列

*/

*/

21.

void

lnsertFinish（PCB*in）;

/*时间片队列

*/

22.

void

PrioCreate（）;

/*优先级输入函数

*/

23.

void

TimeCreate（）;

/*时间片输入函数

*/

24.

void

Priority。

;

/*

按照优先级调度

*/

25.

void

RoundRun（）;

/*

时间片轮转调度

*/

26.

27.

intmain（void）

{

28.

29.

30.

charchose;

printf（"请输入要创建的进程数目:

\n"）;

scanf（"%d"，&num）;

31.

32.

getchar（）;

printf（"输入进程的调度方法：

（P/R）\n"

）;

33.

scanf（"%c"，&chose）;

34.

switch（chose）

35.

36.

case'P':

37.

case'p':

38.

PrioCreate（）;

39.

40.

Priority（）;break;

41.

case'R':

42.

case'r'

43.

44.

TimeCreate（）;

RoundRun（）;

45.

break;

46.

default:

break;

47.

48.

Output（）;

49.

return0;

50.

51.

voidGetFirst（）

/*取得第一个就绪队列节点

*/

52.

53.

54.

run=ready;

if（ready!

=NULL）

55.

56.

run->state=

'R';

57.

ready=ready->next;

58.

run->next=NULL;

59.

60.

61.

62.

voidOutput（）

/*输出队列信息*/

63.

64.

{

PCB*p;/*p=ready;*/

65.

printf（"进程名\t优先级\t时间片\tcpu

时间\t需要时间\t进程状态\t计数器\n"）;

66.

p=ready;

67.

while（p!

=NULL）

68.

69.

printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n"

p->name,p->pno,p->round,p->cputim

e,p->needtime,p->state,p->count）;

70.

p=p->next;

71.

72.

73.

p=finish;

while（p!

=NULL）

74.

75.

printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n"

p->name,p->pno,p->round,p->cputim

e,p->needtime,p->state,p->count）;

76.

p=p->next;

77.

78.

p=run;while（p!

=NULL）

79.

80.

printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n"

p->name,p->pno,p->round,p->cputim

e,p->needtime,p->state,p->count）;

81.

p=p->next;

82.

83.

84.

voidInsertPrio（PCB*in）

/*创建优先级队列，规定优先数越小，优先级越低

*/

85.

86.

PCB*fst,*s,*r;

87.

88.

intb;

s=in;/*待插入的PCB指针*/

89.

90.

fst=ready;/*就绪队列头指针*/r=fst;/*r做fst的前驱指针*/

91.

b=1;

92.

while（（fst!

=NULL）&&b）

/*根据优先数确定插入位置*/

93.

if（fst->prio>=s->prio）

{r=fst;

96.

fst=fst->next;

97.

}

98.

else

99.

b=0;

100.

if（r!

=fst）/*如果条件成立说明插入在r与fst之间*/

101.

{

102.

r->next=s;

103.

s->next=fst;

104.

}

105.

else

106.

{

107.

s->next=fst;/*否则插入在就绪队列的头*/

108.

ready=s;

109.

}

110.

}

111.

voidInsertTime（PCB*in）

/*将进程插入到就绪队列尾部

112.

{

113.

PCB*fst;

114.

fst=ready;

115.

116.

if（ready==NULL）

117.

{

118.

in->next=ready;

119.

ready=in;

120.

}

121.

else

122.

{

123.

while（fst->next!

=NULL）

124.

{

125.

fst=fst->next;

126.

}

127.

in->next=fst->next;

128.

fst->next=in;

129.

}

130.

}

131.

voidlnsertFinish（PCB*in）

/*将进程插入到完成队列尾部

132.

{

133.

PCB*fst;

134.

fst=finish;

135.

if（finish==NULL）

136.

{

137.

in->next=finish;

138.

finish=in;

139.

}

140.

else

*/

*/

141.

142.

while（fst->next!

=NULL）

143.

144.

fst=fst->next;

145.

146.

in->next=fst->next;

147.

fst->next=in;

148.

149.

150.

voidPrioCreateO

/*优先级调度输入函数*/

151.

152.

PCB*tmp;

153.

inti;

154.

155.

156.

printf（"输入进程名字和进程所需时间：

\n"）;

for（i=0;i

157.

158.

159.

if（（tmp=（PCB*）malloc（

{

sizeof（PCB）））==NULL）

160.

perror（"malloc"）;

161.

exit

（1）;

162.

163.

scanf（"%s",tmp->name）;

164.

getcharO;

/*吸收回车符号*/

165.

166.

scanf（"%d"，&（tmp->needtime））;

tmp->cputime=0;

167.

tmp->state=W;

168.

tmp->prio=50-tmp->needtime;

/*设置其优先级，需要的时间越多,

优先级越低

*/

169.

tmp->round=0;

170.

tmp->count=0;

171.

172.

InsertPno（tmp）;

}

/*按照优先级从高到低，插入到就绪队列

*/

173.

174.

175.

voidTimeCreate（）

{

/*时间片输入函数*/

176.

PCB*tmp;

177.

inti;

178.

179.

printf（"输入进程名字和进程时间片所需时间：

\n"）;

180.

for（i=0;i

181.

182.

{

if（（tmp=（PCB*）malloc（

sizeof（PCB）））==NULL）

183.

184.

{

185.

Perror（"malloc"

）

186.

exit

（1）;

187.

}

188.

scanf（"%s",tmp->name）;

189.

getcharO;

190.

scanf（"%d"，&（tmp->needtime））;

191.

tmp->cputime=C

）;

192.

tmp->state=

W

193.

tmp->prio=0;

194.

tmp->round=2;

/*假设每个进程所分配的时间片是2*/

195.

tmp->count=0;

196.

lnsertTime（tmp）;

197.

}

198.

}

199.

voidPriority（）

/*按照优先级调度，每次执行一个时间片*/

200.

{

201.

intflag=1;

202.

203.

GetFirst（）;

204.

while（run!

=NULL）

/*当就绪队列不为空时，则调度进程如执行队列执行

205.

{

206.

Output（）;/*输出每次调度过程中各个节点的状态*/

207.

while（flag）

208.

{

209.

run->pno-=0;

/*优先级减去三，若设为0则优先级不变*/

210.

run->cputime++;

/*CPU时间片加一*/

211.

run->needtime--;

/*进程执行完成的剩余时间减一*/

212.

if（run->needtime

==

0）/*如果进程执行完毕，将进程状态置为F:

*/

213.

{

214.

run->state=

'F'

215.

run->count++;

/*进程执行的次数加一*/

216.

InsertFinish（run）;

217.

flag=0;

218.

}

219.

else/*将进程状态置为W,入就绪队列*/

220.

{

221.

run->state=

w

222.

run->count++;

/*

进程执行的次数加一*/

223.

InsertTime（run）;

224.

flag=0;

225.

}

226.

将其插入到完成队列

*/

227.

}

228.

flag=1;

229.

GetFirstO;/*继续取就绪队列队头进程进入执行队列

230.

}

231.

}

232.

voidRoundRun（）

/*时间片轮转调度算法*/

233.

{

234.

235.

intflag=1;

236.

237.

GetFirst（）;

238.

while（run!

=NULL）

239.

{

240.

Output（）;

241.

while（flag）

242.

{

243.

run->count++;

244.

run->cputime++;

245.

run->needtime--;

246.

if（run->needtime==

0）/*进程执行完毕*/

247.

{

248.

run->state='F'

249.

InsertFinish（run）;

250.

flag=0;

251.

}

252.

elseif（run->count

==run->round）/*时间片用完

253.

{

254.

run->state=W

255.

run->count=0;

/*计数器清零，为下次做准备*/

256.

InsertTime（run）;

257.

flag=0;

258.

}

259.

}

260.

flag=1;

261.

GetFirst（）;

262.

}

[263.

}

*/

*/

实验结果

费扎密謝调宜方曲仲畑

ffit护呈名字和诜若时何片所需时卧

，口

C3进程名

优先级

0

优先级

0

门

即囲间要时间

0

0

0

叩11时闾

0

2

进程若

■

ft%*3

谡程名

0

0

优弼

Q

优尼及

g

3

7

需骑m间

3

5

2

cpu时间再要时间

25

27

03_

时间需皤时何

21

25

cpuB^I'b］藩要忖问

1

3

优先抚

优泄及

0

0

-P

4

5

2"^

此图展示

RR算法

1.创建3个进程。

<□

4

2

c;.iiE||b1

4

1

U冲时间需要时I町

4

3

逬程状态

F

详稈廿态

耳

E

退程状总

耳

F

迸稈状态

耳

E

色悝状志

F

进稈壮誉:

W

片

E

逆社忧二

F

0

0

廿徴嚣

0

0

0

r数器

0

0

计教器

0

D

0

计拔蒸

0

0

0

计数予

2.选择R,即RR算法。

3.按照图示，即可看出

a、b、c三个进程状态轮回运行，每次

运行后需要时间减2

jSA世！

ifi罕和谜^所怖闻；

0

汁載蓉

嗣搁

»要时闻

0

SFS帥刖

2

0

0

罠闿片

0

0

此图展示动态优先级算法

1.输入进程数，选择P算法;

2.创建3个进程，输入进程运行需要时间;

3.优先级定义方式为50减去运行所需时间;

4.动态算法：

进程每被执行一遍后，若未完成则优先级减3后

加入就绪队列。

若就绪队列中两个进程优先级一样，则后进

入的在后。