进程管理和调度Word格式文档下载.docx
《进程管理和调度Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《进程管理和调度Word格式文档下载.docx（16页珍藏版）》请在冰豆网上搜索。
voidOutput1（）;
//输出时间片轮转队列信息
voidOutput2（intsumtime）;
//输出优先权调度队列信息
voidInsertPrio（PCB*in）;
//创建优先级队列，规定优先数越小，优先级越高
voidInsertRound（PCB*in）;
//创建时间片就绪队列
voidInsertFinish（PCB*in）;
//创建完成队列
voidPrioCreate（）;
//优先级输入函数
voidTimeCreate（）;
//时间片轮转调度算法——输入函数
voidPriority（）;
//按照优先级调度
voidRoundRun（）;
//时间片轮转调度
voidupdate_priority（int&
add_priority）;
//等待队列的优先权更新
PCB*ready=NULL,*run=NULL,*finish=NULL;
//定义3个队列，就绪队列，执行队列和完成队列
intmain（）
charchoose;
FILE*fp;
cout<
<
"
*****************欢迎进入进程管理和调度的算法模拟*****************\n"
endl;
*****************************主菜单*****************************"
输入进程的调度方法（请输入对应数字）：
1.抢占式动态优先权调度（手工输入）"
2.时间片轮转调度（手工输入）"
3.抢占式动态优先权调度（从文件读入已设定的的数据）"
4.时间片轮转调度（从文件读入已设定的的数据）"
5.退出程序"
cin>
>
choose;
switch（choose）
{
case'
1'
:
PrioCreate（）;
Priority（）;
Output1（）;
break;
2'
TimeCreate（）;
RoundRun（）;
3'
fp=freopen（"
yxj.txt"
"
r"
stdin）;
//优先级输入文件
fclose（fp）;
4'
sjp.txt"
//时间片输入文件
5'
exit
（1）;
default:
break;
}
return0;
}
/*
voidGetFirst（）//取得就绪队列第一个节点
run=ready;
if（ready!
=NULL）
strcpy（run->
state,"
Run"
）;
ready=ready->
next;
run->
next=NULL;
}
*/
intGetFirst（intsumtime）//取得就绪队列第一个节点
{
PCB*fst,*temp1,*temp2,*temp3;
=NULL&
&
sumtime<
ready->
arrive）//ready队列改变
{
fst=ready;
while（sumtime<
fst->
arrive）//寻找到达时间最小的
{
temp1=fst;
//记录符合条件的前面一个值
fst=fst->
if（fst==NULL）
{
sumtime++;
Output2（sumtime）;
fst=ready;
if（sumtime>
=fst->
arrive）//搜索一轮之后，设置CPU时间+1，即全部进程都等待
{
run=ready;
if（ready!
{
strcpy（run->
ready=ready->
run->
}
returnsumtime;
}
}
}
temp2=fst;
temp1->
next=fst->
temp3=ready;
ready=fst;
ready->
next=temp3;
run=ready;
strcpy（run->
ready=ready->
run->
returnsumtime;
}
voidOutput2（intsumtime）
-------------------------------------------------------"
PCB*p;
p=run;
现在CPU时间为：
sumtime<
if（p==NULL&
ready==NULL）
cout<
所有进程调度已经完成！
队列具体信息如下：
exit（0）;
进程名到达时间服务时间剩余时间优先权状态"
if（p!
setw（3）<
p->
name<
\t"
<
setw（5）<
arrive<
setw（7）<
fuwu_time<
setw（9）<
needtime<
setw
（2）<
prio<
state<
p=p->
p=ready;
while（p!
//创建优先级就绪队列，规定优先权数越小，优先级越低，0为最低优先权数
voidInsertPrio（PCB*in）
PCB*fst,*temp;
fst=ready;
intflag=0;
if（ready==NULL）//如果队列为空，则为第一个元素
in->
next=ready;
ready=in;
else//查到合适的位置进行插入
if（in->
prio>
fst->
prio）//比第一个还要大，则插入到队头
{
in->
ready=in;
}
else
while（fst->
next!
=NULL）//移动指针查找第一个别它小的元素的位置进行插入
{
temp=fst;
fst=fst->
if（in->
prio）//插入就绪队列中
in->
next=fst;
temp->
next=in;
flag=1;
break;
elseif（in->
prio==fst->
prio&
in->
arrive）//优先级一样，若先到达则优先考虑
}
if（fst->
next==NULL&
flag==0）//已经搜索到队尾，则其优先级数最小，将其插入到队尾即可
in->
next=NULL;
fst->
voidInsertRound（PCB*in）//将进程插入到就绪队列尾部——时间片轮转就绪队列
PCB*fst;
if（ready==NULL）
//将进程插到空就绪队列
ready=in;
else
while（fst->
=NULL）
fst=fst->
//遍历到队列尾部
in->
next=fst->
//将进程插到就绪队列尾部
voidInsertFinish（PCB*in）//将进程插入到完成队列尾部
fst=finish;
if（finish==NULL）
next=finish;
//将进程插到空完成队列
finish=in;
//将进程插到完成队列尾部
add_priority）
while（fst!
=NULL）//如果队列为空，则为第一个元素
if（fst->
=minprio）//优先权小于minprio,系统假定为50，则优先权+add_priority；
fst->
prio=fst->
prio+add_priority;
fst=fst->
voidTimeCreate（）//时间片轮转调度算法——输入函数
intnum;
//要创建的进程数目
请输入要创建的进程数目:
\n"
;
num;
PCB*tmp;
inti;
floatT_xiangying;
//响应时间
请输入响应时间\n"
T_xiangying;
//T_xiangying=TXIANGYING;
请输入进程名称到达时间服务时间\n"
for（i=0;
i<
num;
i++）
if（（tmp=（PCB*）malloc（sizeof（PCB）））==NULL）
perror（"
malloc"
exit
（1）;
cin>
tmp->
name>
arrive>
fuwu_time;
strcpy（tmp->
state,"
Wait"
tmp->
prio=0;
round=T_xiangying/num;
//系统假设时间片是1
count=0;
tmp->
needtime=tmp->
//把服务时间赋值给还需时间
InsertRound（tmp）;
voidRoundRun（）//时间片轮转调度算法
intsum_cputime=0;
intflag=1;
**********时间片轮转调度算法具体实现过程：
**********"
Output2（sum_cputime）;
GetFirst（sum_cputime）;
while（run!
//Output（）;
while（flag）
sum_cputime++;
run->
count++;
needtime--;
if（run->
needtime==0）//进程执行完毕
state,"
Finish"
run->
zhouzhuan=sum_cputime-run->
arrive;
ave_daiquan=（run->
zhouzhuan*1.0）/run->
InsertFinish（run）;
flag=0;
elseif（run->
count==run->
round）//时间片用完
strcpy（run->
//计数器清零，为下次做准备
InsertRound（run）;
flag=1;
voidOutput1（）//输出队列，按完成时间排序
进程名到达时间完成时间服务时间周转时间带权周转时间"
p=finish;
<
arrive+p->
zhouzhuan<
ave_daiquan<
p=p->
************************感谢您的使用！
************************"
voidPrioCreate（）//优先级调度输入函数
请输入进程名称到达时间服务时间优先级初值\n"
fuwu_time>
prio;
round=0;
//假设时间片是0
InsertPrio（tmp）;
voidPriority（）//按照优先级调度，每次执行一个时间片
intadd_prio;
//add_prio=ADDPRIO;
//优先权的增加值
请输入优先权的增加值:
add_prio;
intupdate_time;
//update_time=UPDATETIME;
//提升优先权的时间间隔
提升优先权的时间间隔:
update_time;
***************您输入的调度信息如下：
***************"
//输入数据，为改变状态
inttimecount=0;
sum_cputime=GetFirst（sum_cputime）;
**********抢占式优先级调度算法具体实现过程：
//输出每次调度过程中各个节点的状态
while（run!
=NULL）//执行进程
while（flag）
run->
prio=run->
prio-1;
//优先权减1
//进程还需要的时间片数减1
sum_cputime++;
timecount++;
//时间片计数器
if（run->
needtime==0）//如果进程执行完毕，将进程状态置为Finish，将其插入到完成队
strcpy（run->
run->
InsertFinish（run）;
Output2（sum_cputime）;
//输出完成进程信息
if（timecount==update_time）
timecount=0;
update_priority（add_prio）;
else//将进程状态置为W，入就绪队列
strcpy（run->
InsertPrio（run）;
flag=0;
flag=1;
sum_cputime=GetFirst（sum_cputime）;
//继续取就绪队列队头进程进入执行队列
Output2（sum_cputime）;
//输出每次调度过程中各个节点的状态
升级会员 