进程调度优胜算法实验报告Word格式.docx

进程调度优胜算法实验报告Word格式.docx

《进程调度优胜算法实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《进程调度优胜算法实验报告Word格式.docx（13页珍藏版）》请在冰豆网上搜索。

//进程状态//2--表示"

执行"

状态//1--表示"

就绪"

状态//0--表示未到达//3表示运行结束

intcpu_time;

//运行需要的CPU时间（单位秒）

intused_time;

//已运行时间

intarrive_time;

//进程到达时间

doublepriority;

//因高响应比涉及到动态优先权

intfinsh_time;

//进程完成时间

charname[20];

//进程名称

intstart_time;

//开始执行时间

}PCB,*PPCB;

#endif

#ifndefNODE_TYPE

#defineNODE_TYPE

建立循环单链表的头文件QueueNode.h：

#include"

PCB.h"

//链队列的结构体定义，用带头结点的循环单链表实现

typedefstructnode

PCBp_cb;

structnode*next;

}Node,*PNode;

voidinit_queue（PNode*rear）;

//初始化队列

PPCBde_queue（PNode*rear）;

//出队

PPCBget_queue（PNode*rear）;

//取队头元素

voiden_queue（PNode*rear,PPCBp_pcb）;

//入队

intqueue_empty（PNode*rear）;

//判断队列是否为空

主函数代码部分：

main.c函数部分代码

#include<

stdlib.h>

QueueNode.h"

stdio.h>

string.h>

time.h>

queue.c"

//定义全局变量

inttime_slice;

//时间片

intunuse_cpu=0;

//cpu空闲的时间

PNode*ready_queue;

//就绪队列

PCBp_cb[10];

//p_cb数组,初始时存放用户输入的进程

intprocess_count=0;

//用户输入的进程个数

intcurrent_time=0;

//当前时间

intchoise;

PPCB（*p_select）（）;

//函数指针,选择不同的调动算法，指向不同的选择函数

charprocess_change[50][20];

//记录进程调用顺序（每一次切换进程引起调用）

intcount=0;

//记录进程调用次数（切换进程的次数）

intchange_time[50];

//记录切换进程时的时间

//函数声明

voidstart_state（）;

//初始化开始时的信息

voiddisplay（）;

//显示pcb的信息

voidinsert（）;

//把当前时间到达的进程（pcb）插入队列

PPCBselect_by_priority（）;

//从队列中选择进程（按优先级）

PPCBselect_at_head（）;

//从队列选择进程，选择对头元素即可

voidrun（PPCBp_pcb）;

//某个进程运行，直到用完一个时间片或者该进程运行完成

voiddispath（）;

//进程调度

doublecalculate（）;

//计算cpu的利用率

voidsort_pcb（）;

//按进程的完成时间排序

intfinshed（）;

//判断所有进程是否执行完成

//主函数

voidmain（）

ready_queue=（PNode*）malloc（sizeof（PNode））;

init_queue（ready_queue）;

start_state（）;

dispath（）;

sort_pcb（）;

display（）;

}

//初始化，输入进程初始信息

voidstart_state（）

inti,j=1;

printf（"

请输入进程个数（小于十个）:

\n"

）;

scanf（"

%d"

&

process_count）;

请输入时间片的大小:

time_slice）;

进程名到达时间服务时间优先级\n"

for（i=0;

i<

process_count;

i++）{

printf（"

请输入第%d个进程的信息:

i+1）;

%s%d%d%lf"

p_cb[i].name,&

p_cb[i].arrive_time,&

p_cb[i].cpu_time,&

p_cb[i].priority）;

p_cb[i].pid=i+1;

p_cb[i].finsh_time=-1;

//为了便于判断是否全部进程完成

p_cb[i].start_time=-1;

//为了便于判断此程序是否已经开始

}

pleaseselectthedispathmethod:

\n（1—时间片轮转法，2—时间片轮转法与高优先权法结合，3—高响应比优先）\n"

choise）;

if（choise==1）

p_select=select_at_head;

elseif（choise==2）

p_select=select_by_priority;

elseif（choise==3）{

}else{

输入错误！

！

"

exit（0）;

voiddispath（）

PPCBp_pcb;

do{

//1.在当前时间如果有进程到达，则插入就行队列

insert（）;

//2、根据调度算法从就绪队列选出要执行的进程

p_pcb=p_select（）;

//3.把cpu分配给这个进程

run（p_pcb）;

}while（!

finshed（））;

//根据完成时间的先后对pcb进行排序

voidsort_pcb（）

inti,index,j;

PCBtemp;

process_count-1;

index=i;

for（j=i;

j<

j++）

if（p_cb[index].finsh_time>

p_cb[j].finsh_time）{

index=j;

}

temp=p_cb[index];

p_cb[index]=p_cb[i];

p_cb[i]=temp;

//显示pcb信息

voiddisplay（）

inti,turnaround_time;

doublesum_right_turnaround_time=0,sum_turnaround_time=0,right_turnaround_time;

进程名到达时间服务时间开始执行时间完成时间周转时间带权周转时间\n"

turnaround_time=p_cb[i].finsh_time-p_cb[i].arrive_time;

right_turnaround_time=（turnaround_time）*1.0/p_cb[i].cpu_time;

sum_turnaround_time+=turnaround_time;

sum_right_turnaround_time+=right_turnaround_time;

%-11s%-12d%-12d%-11d%-7d%-10d%-10.4f\n"

p_cb[i].name,p_cb[i].arrive_time,p_cb[i].cpu_time,p_cb[i].start_time,p_cb[i].finsh_time,turnaround_time,right_turnaround_time）;

平均周转时间：

%.4f\n"

sum_turnaround_time/process_count）;

平均带权周转时间：

sum_right_turnaround_time/process_count）;

\ncpu利用率：

calculate（））;

\n进程切换详细信息：

\n\n"

count;

在时间是%d的时候，%s获得cpu\n"

change_time[i],process_change[i]）;

voidinsert（）

inti;

if（p_cb[i].arrive_time==current_time&

&

p_cb[i].state==0）{

p_cb[i].state=1;

en_queue（ready_queue,&

p_cb[i]）;

PPCBselect_by_priority（）

intid;

PNodehead,p;

PPCBp_pcb=（PPCB）malloc（sizeof（PCB））;

if（choise==3）{//此时选择的是高响应比优先调度算法

p=（*ready_queue）->

next->

next;

while（p!

=（*ready_queue）->

next）{//给就绪队列的每一个进程赋优先级=（等待时间+要求服务时间）/要求服务时间

p->

p_cb.priority=（1.0*（current_time-p->

p_cb.arrive_time+p->

p_cb.cpu_time）/p->

p_cb.cpu_time）;

p=p->

if（!

queue_empty（ready_queue））{//当就绪队列不空时

head=（*ready_queue）->

//注意用的这个队列带有头结点，所以head指向头结点的下一个结点

priority=head->

p_cb.priority;

while（head!

next）{

if（head->

p_cb.priority>

=priority）{//找到就绪队列中优先级最高的那个进程，并记下它的id

priority=head->

id=head->

p_cb.pid;

}

head=head->

//指向head前一个结点，便宜后面删除结点

p_cb.pid==id）{//找到这个结点，把它从就绪队列中删除，交给cpu处理

*p_pcb=head->

p_cb;

p->

next=head->

if（（*ready_queue）->

p_cb.pid==head->

p_cb.pid）{//当删除的是尾结点时

*ready_queue=p;

}

free（head）;

break;

head=head->

p_pcb->

state=2;

//从就绪队列选出，状态变为执行

if（p_pcb->

start_time==-1）

p_pcb->

start_time=current_time;

returnp_pcb;

}else

returnNULL;

//从队列里选出下一个要执行的进程,选择对头元素即可

PPCBselect_at_head（）

PPCBp_pcb=de_queue（ready_queue）;

if（p_pcb!

=NULL）{//当就绪队列不空时

voidrun（PPCBp_pcb）

if（p_pcb==NULL）{//没有要执行的进程

current_time++;

unuse_cpu++;

return;

//记录进程切换的状态

strcpy（process_change[count],p_pcb->

name）;

change_time[count++]=current_time;

time_slice;

i++）{//运行一个时间片

insert（）;

used_time++;

used_time==p_pcb->

cpu_time）{

finsh_time=current_time;

if（i==time_slice）{

state=1;

en_queue（ready_queue,p_pcb）;

else{//这个进程运行完成

state=3;

p_cb[p_pcb->

pid-1]=*p_pcb;

free（p_pcb）;

//判断是否全部进程都执行完成

intfinshed（）

i++）

if（p_cb[i].state!

=3）

return0;

return1;

doublecalculate（）

return1.0*（current_time-unuse_cpu）/current_time;

queue.c函数部分代码

//initialqueue

voidinit_queue（PNode*rear）

PNodep;

p=（PNode）malloc（sizeof（Node））;

next=p;

*rear=p;

//deleteanodeattheheadofqueue

PPCBde_queue（PNode*rear）

PNodepnode;

queue_empty（rear））{

pnode=（*rear）->

*p_pcb=pnode->

（*rear）->

next=pnode->

if（pnode==*rear）

*rear=（*rear）->

free（pnode）;

//returntherailnode'

sdata

PPCBget_queue（PNode*rear）

*p_pcb=（*rear）->

//insertanodeatthequeue'

stail

voiden_queue（PNode*rear,PPCBp_pcb）

PPCBpp_pcb=（PPCB）malloc（sizeof（PCB））;

*pp_pcb=*p_pcb;

pnode=（PNode）malloc（sizeof（Node））;

pnode->

next=（*rear）->

p_cb=*pp_pcb;

（*rear）->

next=pnode;

*rear=pnode;

//judgethequeueisemptyornot

intqueue_empty（PNode*rear）

if（（*rear）->

next==*rear）

return1;

else

return0;