于基静态优先权和响应比的进程管理系统的设计--毕业设计.doc

基于静态优先权和响应比的进程管理系统的设计

课程设计报告
（本科）

基于静态优先权和响应比的进程管理系统的设计

课程：
操作系统课程设计

学号：

姓名：

班级：

教师：

时间：

计算机科学与技术系

设计名称：
基于静态优先权和响应比的进程管理系统的设计
设计内容、目的与要求：

本课程设计的目的是：加深对进程概念及进程管理各部分内容的理解；熟悉静态优先权和响应比两种进程调度算法。

本课程设计的要求是：（1）设计一个完整的进程调度系统，系统中至少包括5个进程；（2）定义PCB；（3）采用链表管理就绪队列；（4）结果要能够显示出进程的调度序列及进入系统的时间、运行时间等必要信息。（5）设计的输入数据要能体现算法的思想。

计划与进度安排：

6月7日 按照课程设计要求建立流程图，架起大概框架
6月8日到12日 输入主函数和各个过程的程序
6月13日到20日 调试程序并记录调试中的问题，努力解决
6月21日到25日 系统测试，演示设计成果，将调试结果截图保留下来
6月26日到30日 整理完善课程设计说明书

设计过程、步骤（可加页）：

①进程创建模块
此模块用来创建进程实体，设置进程的到达时间、服务时间、开始时间。
②就绪队列模块
此模块用链式队列来实现，用来存放已经创建的进程，为下面的两个模块来服务。
③静态优先权模块
此模块是先进先出算法的实现模块，此模块遍历模块中的就绪队列来找到到达时间的从小到的大的序列。
④响应比模块
此模块是短进程优先调度算法的实现模块，此模块遍历中的就绪队列来找到服务时间从小打到的序列。

开始
创建进程
输入进程名称、大小、创建时间、服务时间
就绪队列查看
选择调度算法
（FCFS/SPF）
输出结果
结束

程序源代码如下：
//基于静态优先权和响应比的进程管理系统的设计
#include
#include
#include
#include
#define false 0
#define true 1
//定义链表的结构体
typedef struct {
char id[20]; //进程名称
int f_priority; //初始优先权
int arrive_time; //到达时间
int service_time; //服务时间
int start_time; //开始时间
int finish_time; //完成时间
int wait_time; //等待时间
float priority; //响应比(优先权)
}datatype;//15

//定义链表
typedef struct node{
datatype data;
struct node * prior;//前一节点指针
struct node * next; //后一节点指针 22
}listnode,* linklist;
linklist head,list_static,list_rp;
listnode *p,*q,*m,*n,*rear,*z;

//函数说明
int menu_select();
linklist enter(void);
void display(linklist head);
void display_static(linklist head);
void display_rp(linklist head);//30

//主函数
void main()
{
for(;;){

switch(menu_select())
{
case 1:
printf("\t*******************************\n");
printf("\t************创建进程***********\n");
printf("\t*******************************\n");
head=enter();
system("cls");
break;

case 2:
printf("\t*******************************\n");
printf("\t**********显示就绪队列*********\n");
printf("\t*******************************\n");
display(head);
break;
case 3:
printf("\t*******************************\n");
printf("\t***********静态优先权**********\n");
printf("\t*******************************\n");
display_static(head);
break;
case 4:
printf("\t*******************************\n");
printf("\t**********高响应比优先*********\n");
printf("\t*******************************\n");
display_rp(head);
break;
case 0:
printf("\n谢谢使用！\n");
return;

default :
break;//68
}
}
}

//****************
//菜单选择函数程序
//****************
int menu_select()
{
int sn;
printf("\t基于静态优先权和响应比的进程管理系统\n\n");
printf("\t==========================================\n");//80
printf("\t 1.创建进程队列\n");
printf("\t 2.显示就绪队列\n");
printf("\t 3.静态优先权\n");
printf("\t 4.高响应比优先\n");
printf("\t 0.退出\n");
printf("\t==========================================\n");
printf("\t请选择0~4:");

while(1){

scanf("%d",&sn);//93
getchar();

if(52\t输入错误，重选0-4：");
sn=9;
continue;
}
else{
break;
}
}
return sn;//101
}

//****************
//**建立进程队列**
//****************
linklist enter(void)
{
linklist head=(listnode *)malloc(sizeof(listnode));
listnode *p,*rear;
char flag='y';
rear=head;

while(flag=='y')
{
p=(listnode *)malloc(sizeof(listnode));
printf("%s\t","\t请输入进程名id:");//120
scanf("%s",p->data.id);
printf("%s\t","\t初始优先权:");
scanf("%d",&p->data.f_priority);
printf("%s\t","\t到达时间:");
scanf("%d",&p->data.arrive_time);
printf("%s\t","\t服务时间");
scanf("%d",&p->data.service_time);
rear->next=p;
p->prior=rear;//双向链表
rear=p;

//判断是否还继续输入新的
flag='n';
printf("\n\t继续输入吗？(y/n)");
getchar();
scanf("%c",&flag);
}//while()结束

rear->next=NULL;
return head;

}

//******************
//***显示进程队列***
//******
void display(linklist head)
{
listnode *p;
if(head==NULL||head->next==NULL) {printf("\n\t空队列 任意键返回主菜单");getchar();system("cls");return;}
p=head->next;
printf("\n\t*************** 以下为队列信息************");
printf("\n\t进程名\t初始优先权\t到达时间\t服务时间\t");
printf("\n\t------------------\n");
while(p!=NULL)
{

printf("\t%s",p->data.id);
printf("\t%d",p->data.f_priority);
printf("\t\t%d",p->data.arrive_time);
printf("\t\t%d",p->data.service_time);
printf("\n\t----------------------------------------------------\n");

p=p->next;
}
getchar();
system("cls");
}

//******************
//**静态优先权算法**
//******************
void display_static(linklist head)
{
int size=0;
//假设当前时间为0
int time=0;
//假设未进程满足条件
bool have=false;//180
listnode *p,*q,*rear,*m,*n,*z;
if(head==NULL||head->next==NULL) {printf("\n\t空队列 任意键返回主菜单");getchar();system("cls");return;}

//创建一个新的链表用来存储静态优先权算法后得到的执行队列
linklist list_static=(listnode *)malloc(sizeof(listnode));
rear=list_static;
p=(listnode *)malloc(sizeof(listnode));
//取得链表节点数
p=head->next;//190
while(p!=NULL){
size++;
p=p->next;
}
p=head->next;
printf("%d",size);
//临时指针
m=(listnode *)malloc(sizeof(listnode));
m->data=head->next->data;
q=(listnode *)malloc(sizeof(listnode));
q->data=head->next->data;
//最外层循环 选取新排列的链表
int i;
for(i=1;i<=size;i++){
have=false;//207
//遍历链表 挑选出符合条件的进程
while(p!=NULL){
//如果当前时间下 有进程已到达
if(p->data.arrive_time<=time){
have=true;
//如果其优先权比原有优先权大 则替换 选出其中优先权最大的
if(q->data.f_prioritydata.f_priority){
//把p节点 复制成q
q->data=p->data;
}

}
//进程还未到达 选出到达时间最小且优先权最大的
if(p->data.arrive_time>time){
//同时到达
if(m->data.arrive_time==p->data.arrive_time){
//优先权
if(m->data.f_prioritydata.f_priority){
m->data=p->data;
}//224
}
if(m->data.arrive_time>p->data.arrive_time){
m->data=p->data;
}
}
p=p->next;
}//while循环结束
z=(listnode *)malloc(sizeof(listnode));
n=(listnode *)malloc(sizeof(listnode));
if(have==true){
z->data=q->data;
z->data.start_time=time;
}else{
z->data=m->data;
z->data.start_time=z->data.arrive_time;
}
n=(listnode *)malloc(sizeof(listnode));
n->data=z->data;
n->data.finish_time=n->data.start_time+n->data.service_time;
n->data.wait_time=n->data.start_time-time;
time=n->data.finish_time;
rear->next=n;
if(i!=1){
n->prior=rear;
}
rear=n;

//选出的进程需要从原来的链表中删除
p=head->next;
while(p!=NULL){
//搜索到要删除的节点
if(strcmp(z->data.id,p->data.id)==0){
if(p->next!=NULL){
p->prior->next=p->next;
p->next->prior=p->prior;
}else{
p->prior->next=NULL;
}
free(p);
break;
}
p=p->next;
}
if(head->next!=NULL){
p=(listnode *)malloc(sizeof(listnode));
p=head->next;
q->data=head->next->data;
m->data=head->next->data;
}else{
p=NULL;
}

}//for循环结束//276

rear->next=NULL;
rear=head;
p=list_static->next;
printf("\n\t*************** 非抢占静态优先权************");
printf("\n进程名\t初始优先权\t到达时间\t服务时间\t开始时间\t完成时间\t");
printf("\n---------------------------------------------------------------------\n");
while(p!=NULL)
{

printf("%s",p->data.id);
printf("\t%d",p->data.f_priority);
printf("\t\t%d",p->data.arrive_time);
printf("\t\t%d",p->data.service_time);
printf("\t\t%d",p->data.start_time);
printf("\t\t%d",p->data.finish_time);
printf("\n-----------------\n");

z=(listnode *)malloc(sizeof(listnode));
z->data=p->data;

rear->next=z;
z->prior=rear;
rear=z;//300

p=p->next;
}
rear->next=NULL;
getchar();
system("cls");
}

//******************
//***高响应比优先**
//******************
void display_rp(linklist head)
{
int size=0;
float rp=0,rpq=0,rpm=0;
//假设当前时间为0
int time=0;
//假设未进程满足条件
bool have=false;//325
listnode *p,*q,*rear,*m,*n,*z;
if(head==NULL||head->next==NULL) {printf("\n\t空队列 任意键返回主菜单");getchar();system("cls");return;}

//创建一个新的链表用来存储高响应比优先权算法后得到的执行队列
linklist list_rp=(listnode *)malloc(sizeof(listnode));
rear=list_rp;
p=(listnode *)malloc(sizeof(listnode));
//取得链表结点数
p=head->next;
while(p!=NULL){
size++;
p=p->next;
}
p=head->next;
printf("%d",size);
//临时指针
m=(listnode *)malloc(sizeof(listnode));
m->data=head->next->data;
q=(listnode *)malloc(sizeof(listnode));
q->data=head->next->data;//340
int i;
//最外层循环 选取新排列的链表
for(i=1;i<=size;i++){
have=false;//347

//遍历链表 挑选出符合条件的进程
while(p!=NULL){
//如果当前时间下 有进程已到达
if(p->data.arrive_time<=time){
have=true;
//比较响应比 (等待时间/服务时间)+1
rp=(float)((time-p->data.arrive_time)/p->data.service_time)+1;
rpq=(float)((time-q->data.arrive_time)/q->data.service_time)+1;
//取其中响应比高的进程
if(rpqdata=p->data;
}
}
//进程还未到达 选出最先到达的
if(p->data.arrive_time>time){
if(m->data.arrive_time>p->data.arrive_time){
m->data=p->data;
}
}
p=p->next;
}//while循环结束
z=(listnode *)malloc(sizeof(listnode));
n=(listnode *)malloc(sizeof(listnode));
if(have==true){
//有进程满足
z->data=q->data;
z->data.start_time=time;
}else{
//未有进程满足
z->data=m->data;
z->data.start_time=z->data.arrive_time;
}
n=(listnode *)malloc(sizeof(listnode));
n->data=z->data;
n->data.finish_time=n->data.start_time+n->data.service_time;
n->data.priority=(float)(n->data.start_time-n->data.arrive_time)/n->data.service_time+1;
timen->data.finish_time;
rear->next=n;
if(i!=1){
n->prior=rear;
}
rear=n;
//选出的进程需要从原来的链表中删除
p=head->next;
while(p!=NULL){
//搜索到要删除的节点//390
if(strcmp(z->data.id,p->data.id)==0){
if(p->next!=NULL){
p->prior->next=p->next;
p->next->prior=p->prior;
}else{
p->prior->next=NULL;
}
free(p);
break;
}
p=p->next;
}
if(head->next!=NULL){
p=(listnode *)malloc(sizeof(listnode));
p=head->next;
q->data=head->next->data;
m->data=head->next->data;
}else{
p=NULL;
}
}//for循环结束
rear->next=NULL;
rear=head;
p=list_rp->next;
printf("\n\t***************高响应比优先************");
printf("\n进程名\t到达时间\t服务时间\t开始时间\t完成时间\t响应比");
printf("\n-------------------------------------------------------------------------------\n");
while(p!=NULL)
{

printf("%s",p->data.id);
printf("\t%d",p->data.arrive_time);
printf("\t\t%d",p->data.service_time);
printf("\t\t%d",p->data.start_time);
printf("\t\t%d",p->data.finish_time);
printf("\t\t%02f",p->data.priority);
printf("\n-------------------------------------------------------------------------------\n");

z=(listnode *)malloc(sizeof(listnode));
z->data=p->data;

rear->next=z;
z->prior=rear;
rear=z;

p=p->next;
}
rear->next=NULL;
getchar();
system("cls");
｝
结果与分析（可以加页）：
1.显示进程管理系统

2.创建五个进程

3.显示就绪队列

4.显示静态优先权的进程队列

5显示高响应比的进程队列

设计体会与建议
邹良群：本人在本次实验中负责整理课程设计的实验说明文档。通过本次操作系统课程设计，使我们小组成员再次回顾了操作系统学习中的相关内容，对设计和调试相应的程序的基础步骤和方法有了更深的认识。
唐佳慧：在本次课程设计中，我主要负责收集资料和查阅书籍，在做这项课程设计的过程中，我们通过思考摸索与查阅资料相结合，并与同组的其他同学讨论,相互学习,使我比较成功的设计了这个系统。通过查阅资料，不断的发现错误并纠正，反复的完善自己的设计，基本上完成了设计的要求，学会了把课本上的知识成功的运用到实际应用中，巩固了自己关于操作系统的知识。
周慧：在本次实验中我主要负责代码的编写与修改。我在设计与查阅资料和参考别人的程序中，发现了操作系统这门课的非常强大的功能，及其广泛的应用性，并深深的体会到了自己设计出一个成功的系统的乐趣，并且意识到自己在编程方面的能力还很不足，真的需要多多加强学习。通过这次实验倒是积累了编写程序的经验，受益匪浅。
通过这次课程设计，加深了我们对操作系统这门课程的理解，尤其是进程的管理。虽然我们的这个进程管理系统功能很少，模拟的真实性不高，但毕竟是基本上完成了课程设计的要求。

16