基于多队列反馈的进程调度.docx

基于多队列反馈的进程调度.docx

《基于多队列反馈的进程调度.docx》由会员分享，可在线阅读，更多相关《基于多队列反馈的进程调度.docx（31页珍藏版）》请在冰豆网上搜索。

基于多队列反馈的进程调度

《操作系统》综合实训项目设计文档

【大纲】

（不用打印，提交电子稿即可！

）

一、基本信息

项目名称：

成人姓名、学号、完成日期

项目名称：

基于时间片的多队列反馈的进程管理系统

完成日期:

2017.5.24

二、实验内容与目的

实验内容：

编写程序完成单处理器系统的进程调度，要求采用基于时间片多队列反馈式调度策略调度策略。

具体内容：

1.确定PCB内容及其组织方式。

2.要求模拟进程空闲（新）、就绪、运行、阻塞和完成5个状态。

3.实现进程创建、进程调度、进程阻塞、进程唤醒和进程撤销5个原语。

4.能够模拟进程从生到灭的完整过程。

实验目的:

1.加深进程概念理解，明确进程与程序区别。

2.理解操作系统中进程的组织、创建和调度等方法。

三、主要设计思路和流程图

设计思路：

1定义数据结构

2.设置队列

3.创建进程

4.创建的进程进入就绪队列

5.多级反馈调度

1.）在第一就绪队列里的进程被调度运行，进程状态由等待变为运行，设置时间片计数器，每次运行加1，时间片满后，该进程出队列，进入下一级别的就绪队列。

若是在最后一级别的队列，则在该队列中进行时间片轮转调度

2.）运行进程若是被阻塞的话，该进程出就绪队列，进入阻塞队列，状态变为阻塞态

3.）若是唤醒被阻塞进程，则阻塞进程根据其时间片计数器计入相应的就绪队列

4.）撤销进程，该进程直接出就绪队列

四、主要数据结构及其说明

typedefstructNode

{

charname[20];

charstate;//进程所处的状态,N新建，W等待，B阻塞，R运行，F结束

intround;//时间片计数器

inttime;//运行时间

structNode*next;

}LinkQueueNode,*PCB;//定义PCB

typedefstruct

{

LinkQueueNode*front;

LinkQueueNode*rear;

}LinkQueue;//定义队列

voidinitQueue（LinkQueue*Q）//队列的初始化函数

voidInitializa（）//初始化所有队列

voidRunPrintf（）//打印运行队列

voidBlockPrintf（）//打印阻塞队列

voidReadyPrintf（LinkQueueq）//打印就绪队列

voidputout（）//输出函数

voidEnterQueue（LinkQueue*Q,PCB*p）//进程插入队列函数

intDeleteQueue（LinkQueue*Q,PCB*p）//进程出队列

voidTransferRun（LinkQueue*q1,LinkQueue*q2,PCBq）//进程出就绪队列，入运行队列

voidTransfer（LinkQueue*q1,LinkQueue*q2,PCBq）

//进程唤醒或阻塞时队列转换的函数

intMultiDiapatch（）

//调度函数，若此队列运行的进程时间片满，则进入下一级队列

intrun（）//模拟运行

voidblock（）//模拟阻塞

voidwake（）//模拟唤醒

intCreateprocess（LinkQueue*Q）//进程的创建

voidmeanu（）//菜单函数

五、程序运行时的初值和运行结果

六、源程序并附上注释【可是另一个源程序文件，在此应说明该文件名】

#include

#include

#include

#include

typedefstructNode

{

charname[20];

charstate;//进程所处的状态,N新建，W等待，B阻塞，R运行，F结束

intround;//时间片计数器

inttime;//运行时间

structNode*next;

}LinkQueueNode,*PCB;//定义PCB

typedefstruct

{

LinkQueueNode*front;

LinkQueueNode*rear;

}LinkQueue;

intcount=0;

LinkQueueqRun,qBlock,qReady1,qReady2,qReady3,qReady4;//定义四个就绪队列

voidinitQueue（LinkQueue*Q）//队列的初始化函数

{

Q->front=（LinkQueueNode*）malloc（sizeof（LinkQueueNode））;

if（Q->front!

=NULL）

{

Q->rear=Q->front;

Q->front->next=NULL;

}

}

voidInitializa（）//初始化所有队列

{

initQueue（&qRun）;

initQueue（&qBlock）;

initQueue（&qReady1）;

initQueue（&qReady2）;

initQueue（&qReady3）;

initQueue（&qReady4）;

}

voidRunPrintf（）//打印运行队列

{

PCBp;

printf（"运行队列:

"）;

p=qRun.front->next;

while（p）

{

printf（"%s\t",p->name）;

p=p->next;

}

p=qRun.front->next;

printf（"\n需要时间:

"）;

while（p）

{

printf（"%d\t",p->time）;

p=p->next;

}

printf（"\n进程状态:

"）;

p=qRun.front->next;

while（p）

{

printf（"%c\t",p->state）;

p=p->next;

}

}

voidBlockPrintf（）//打印阻塞队列

{

PCBp;

printf（"\n\n阻塞队列:

"）;

p=qBlock.front->next;

while（p）

{

printf（"%s\t",p->name）;

p=p->next;

}

printf（"\n需要时间:

"）;

p=qBlock.front->next;

while（p）

{

printf（"%d\t",p->time）;

p=p->next;

}

printf（"\n进程状态:

"）;

p=qBlock.front->next;

while（p）

{

printf（"%c\t",p->state）;

p=p->next;

}

}

voidReadyPrintf（LinkQueueq）//打印就绪队列

{

PCBp;

p=q.front->next;

while（p）

{

printf（"%s\t",p->name）;

p=p->next;

}

printf（"\n需要时间:

"）;

p=q.front->next;

while（p）

{

printf（"%d\t",p->time）;

p=p->next;

}

printf（"\n进程状态:

"）;

p=q.front->next;

while（p）

{

printf（"%c\t",p->state）;

p=p->next;

}

}

voidputout（）//输出函数

{

PCBp;

printf（"**************************************************************\n"）;

printf（"**********************多级反馈调度****************************"）;

printf（"\n**************************************************************\n"）;

printf（"说明:

程序中四个就绪队列的时间片分别为10，15，20，30"）;

printf（"\n**************************************************************\n"）;

printf（"************************菜单**********************************\n"）;

printf（"1.创建进程2.阻塞进程3.唤醒进程4.撤销进程0.退出\n"）;

printf（"**************************************************************\n"）;

RunPrintf（）;

BlockPrintf（）;

printf（"\n\n队列1:

"）;

ReadyPrintf（qReady1）;

printf（"\n\n队列2:

"）;

ReadyPrintf（qReady2）;

printf（"\n\n队列3:

"）;

ReadyPrintf（qReady3）;

printf（"\n\n队列4:

"）;

ReadyPrintf（qReady4）;

printf（"\n**************************************************************\n"）;

}

voidEnterQueue（LinkQueue*Q,PCB*p）//进程插入队列函数

{

（*p）->next=NULL;

Q->rear->next=*p;

Q->rear=*p;

}

intDeleteQueue（LinkQueue*Q,PCB*p）//进程出队列

{

if（Q->front==Q->rear）

return0;

*p=Q->front->next;

Q->front->next=（*p）->next;

if（Q->rear==*p）

Q->rear=Q->front;

return1;

}

voidTransferRun（LinkQueue*q1,LinkQueue*q2,PCBq）//进程出就绪队列，入运行队列

{

DeleteQueue（q1,&q）;

q->state='R';

EnterQueue（q2,&q）;

}

voidrunprocess（）

{

PCBp;

intstate1=0,state2=0,state3=0,state4=0;

//state来判断就绪队列是否还有进程

if（qReady1.front!

=qReady1.rear）

{

TransferRun（&qReady1,&qRun,p）;

state1=1;

}

else

{

if（qReady2.front!

=qReady2.rear）

{

TransferRun（&qReady2,&qRun,p）;

state2=1;

}

else

{

if（qReady3.front!

=qReady3.rear）

{

TransferRun（&qReady3,&qRun,p）;

state3=1;

}

else

{

if（qReady4.front!

=qReady4.rear）

{

TransferRun（&qReady4,&qRun,p）;

state4=1;

}

}

}

}

if（state1==0&&state2==0&&state3==0&&state4==0）

{

printf（"队列中无就绪进程！

"）;

}

else

{

system（"cls"）;

putout（）;

}

}

voidTransfer（LinkQueue*q1,LinkQueue*q2,PCBq）

//进程唤醒或阻塞时队列转换的函数

{

DeleteQueue（q1,&q）;

q->state='W';

EnterQueue（q2,&q）;

}

intMultiDiapatch（）

//调度函数，若此队列运行的进程时间片满，则进入下一级队列

{

PCBp;

qRun.front->next->time--;

++count;

if（qRun.front->next->time==0）

{

DeleteQueue（&qRun,&p）;

free（p）;

runprocess（）;

count=0;

}

else

if（qRun.front->next->round==count）

{

if（count==10）

{

qRun.front->next->round=15;

Transfer（&qRun,&qReady2,p）;

}

if（count==15）

{

qRun.front->next->round=20;

Transfer（&qRun,&qReady3,p）;

}

if（count==20）

{

qRun.front->next->round=30;

Transfer（&qRun,&qReady4,p）;

}

if（count==30）

{

qRun.front->next->round=30;

Transfer（&qRun,&qReady4,p）;

}

runprocess（）;

count=0;

}

}

intrun（）//模拟运行

{

if（qRun.front==qRun.rear）//运行队列空，则进行进程队列转换

runprocess（）;

else

{

MultiDiapatch（）;

system（"cls"）;

putout（）;

}

}

voidblock（）//模拟阻塞

{

PCBp;

if（qRun.front!

=qRun.rear）//运行队列不为空，则运行进程出运行队列，进入阻塞队列

{

DeleteQueue（&qRun,&p）;

p->state='B';

EnterQueue（&qBlock,&p）;

system（"cls"）;

putout（）;

}

else

{

system（"cls"）;

putout（）;

printf（"队列中没有进程在运行！

"）;

}

}

voidwake（）//模拟唤醒

{

PCBp;

if（qBlock.front!

=qBlock.rear）

{

//根据时间片；来决定进入的就绪队列

if（qBlock.front->next->round==10）

{

Transfer（&qBlock,&qReady1,p）;

}

else

{

if（qBlock.front->next->round==15）

{

Transfer（&qBlock,&qReady2,p）;

}

else

{

if（qBlock.front->next->round==20）

{

Transfer（&qBlock,&qReady3,p）;

}

else

{

if（qBlock.front->next->round==30）

{

Transfer（&qBlock,&qReady4,p）;

}

}

}

}

}

else

{

system（"cls"）;

putout（）;

printf（"无等待进程!

"）;

}

}

voidendprocess（）

{

PCBp;

if（qRun.front==qRun.rear）

{

printf（"信息提示:

无运行进程,请按Enter键运行进程!

"）;

}

else

{

DeleteQueue（&qRun,&p）;

free（p）;

system（"cls"）;

putout（）;

printf（"信息提示:

选择菜单功能或按Enter键执行进程!

"）;

}

}

intCompareStr（LinkQueueq,charname[20]）//比较字符串是否相同

{

PCBp;

p=q.front->next;

while（p）

{

if（strcmp（p->name,name）==0）

{

return0;

}

p=p->next;

}

return1;

}

intCompareName（charname[20]）

{

PCBp;

p=qRun.front->next;

intflag;

flag=CompareStr（qRun,name）;

if（flag==0）

return0;

flag=CompareStr（qBlock,name）;

if（flag==0）

return0;

flag=CompareStr（qReady1,name）;

if（flag==0）

return0;

flag=CompareStr（qReady2,name）;

if（flag==0）

return0;

flag=CompareStr（qReady3,name）;

if（flag==0）

return0;

flag=CompareStr（qReady4,name）;

if（flag==0）

return0;

return1;

}

intCreateprocess（LinkQueue*Q）//进程的创建

{

PCBp;

charn[20];

p=（PCB）malloc（sizeof（LinkQueueNode））;

printf（"进程名:

"）;

fflush（stdin）;

scanf（"%s",&n）;

while（!

CompareName（n））//判断是否创建了已经创建过的进程

{

printf（"已经有相同名字的进程存在"）;

printf（"\n请重新输入未创建过的进程:

"）;

fflush（stdin）;

scanf（"%s",&n）;

}

strcpy（p->name,n）;

printf（"所需时间:

"）;

fflush（stdin）;

scanf（"%d",&（p->time））;

while（p->time<0）

{

printf（"输入不合法"）;

fflush（stdin）;

scanf（"%d",&（p->time））;

}

p->state='W';

p->round=10;

p->next=NULL;

EnterQueue（Q,&p）;

}

voidmeanu（）//菜单函数

{

charc;

printf（"\n选择功能：

"）;

scanf（"%c",&c）;

while

（1）

{

if（c=='1'）

{

Createprocess（&qReady1）;

system（"cls"）;

putout（）;

printf（"\n选择菜单功能或者按enter执行进程:

\n"）;

while

（1）

{

fflush（stdin）;

scanf（"%c",&c）;

if（c=='\n'）

{

run（）;

printf（"\n选择功能或者按enter继续执行:

"）;

}

else

break;

}

}

elseif（c=='2'）

{

block（）;

printf（"\n选择功能:

"）;

while

（1）

{

fflush（stdin）;

scanf（"%c",&c）;

if（c=='\n'）

{

run（）;

printf（"\n选择功能或者按enter继续执行:

"）;

}

else

break;

}

}

elseif（c=='3'）

{

wake（）;

while

（1）

{

fflush（stdin）;

scanf（"%c",&c）;

if（c=='\n'）

{

run（）;

printf（"\n选择功能或者按enter继续执行:

"）;

}

else

break;

}

}

elseif（c=='4'）

{

endprocess（）;

while

（1）

{

fflush（stdin）;

scanf（"%c",&c）;

if（c=='\n'）

{

run（）;

printf（"\n选择功能或者按enter继续执行:

"）;

}

else

break;

}

}

elseif（c=='0'）

{

exit（0）;

}

else

{

printf（"信息提示:

输入错误!

请选择正确的菜单功能选项:

"）;

while

（1）

{

fflush（stdin）;

scanf（"%c",&c）;

if（c=='\n'）

{

run（）;

printf（"\n选择功能或者按enter继续执行:

"）;

}

else

break;

}

}

}

}

intmain（）

{

Initializa（）;

putout（）;

meanu（）;

}