os30操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法剖析.docx
《os30操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法剖析.docx》由会员分享，可在线阅读，更多相关《os30操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法剖析.docx（13页珍藏版）》请在冰点文库上搜索。
os30操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法剖析
进程或作业先来先服务
。
。
实验要求
.1.完成实验任务并将有关的实验结果保存在电脑磁盘上。
.2.将有关的实验结果写成WORD文档，发邮件到老师的邮箱里。
.3.要写出实验题目，操作步骤和相应的实验结果。
.4.老师的邮箱：
cscqliao@
姓名：
年级专业班级日期年月日成绩
课程名称
计算机操作系统
实验名称
编程进程或作业先来先服务、高优先权、按时间片轮转调度算法（4学时）
实验类型
验证设计
综合创新
【实验目的、要求】
实验目的：
（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。
（2）了解Windows2000/XP中进程（线程）的调度机制。
（3）学习使用Windows2000/XP中进程（线程）调度算法，掌握相应的与调度有关的Win32API函数。
实验要求：
（1）经调试后程序能够正常运行。
（2）采用多进程或多线程方式运行，体现了进程或作业先来先服务、高优先权、按时间片轮转调度的关系。
（3）程序界面美观。
【实验内容】
在WindowsXP、Windows2000等操作系统下，使用C语言，利用相应的WIN32API函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。
【实验环境】（含主要设计设备、器材、软件等）
Pc电脑一台
【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）
定义:
1）先来先服务算法：
如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务（FCFS：
firstcomefirstservice）总是把当前处于就绪队列之首的那个进程调度到运行状态。
2）轮转法就是按一定时间片（记为q）轮番运行各个进程。
如果q是一个定值，则轮转法是一种对各进程机会均等的调度方法。
3）优先级调度的基本思想是，把当前处于就绪队列中优先级最高的进程投入运行，而不管各进程的下一个CPU周期的长短和其他因素。
实验步骤：
（1）需求分析：
了解基本原理，确定程序的基本功能，查找相关资料，画出基本的数据流图；
（2）概要设计：
确定程序的总体结构、模块关系和总体流程；
（3）详细设计：
确定模块内部的流程和实现算法；
（4）上机编码和调试；
（5）运行测试；
（6）编写实验报告。
流程图：
（先来先服务流程图）
（高优先权流程图）
（按时间片轮转调度）
程序说明及实现:
1）先来先服务调度算法：
高响应比优先实现进程调度.（用C语言实现）,
2）优先级调度程序：
该程序由主程序、构造队列子程序、打印子程序、运行子程序构成。
3）时间片轮转法程序：
在此程序中由于程序比较小，未进行分模块设计。
直接采用单一模块。
1先来先服务
＃include
floatt,d;/*定义两个全局变量*/
struct/*定义一个结构体数组，包括进程的信息*/
{
intid;
floatArriveTime;
floatRequestTime;
floatStartTime;
floatEndTime;
floatRunTime;
floatDQRunTime;
intStatus;
}arrayTask[4];/*定义初始化的结构体数组*/
GetTask（）/*给结构体数组赋值，输入到达，服务时间*/
{inti;
floata;
for（i=0;i<4;i++）
{arrayTask[i].id=i+1;
printf（"inputthenumber"）;
printf（"inputthetheArriveTimeofarrayTask[%d]:
",i）;/*用户输入进程的时间，初始为零*/
scanf（"%f",&a）;
arrayTask[i].ArriveTime=a;
printf（"inputtheRequestTimeofarrayTask[%d]:
",i）;
scanf（"%f",&a）;
arrayTask[i].RequestTime=a;
arrayTask[i].StartTime=0;
arrayTask[i].EndTime=0;
arrayTask[i].RunTime=0;
arrayTask[i].Status=0;/*开始默认的标志位零*/
}
}
intfcfs（）/*定义FCFS中寻找未执行的进程的最先到达时间*/
{
inti,j,w=0;/*在结构体数组中找到一个未执行的进程*/
for（i=0;i<4;i++）
{
if（arrayTask[i].Status==0）
{
t=arrayTask[i].ArriveTime;
w=1;
}
if（w==1）
break;
}
for（i=0;i<4;i++）/*查找数组中到达时间最小未执行的进程*/
{
if（arrayTask[i].ArriveTimet=arrayTask[i].ArriveTime;
}/*返回最小到达时间的数组的下标*/
for（i=0;i<4;i++）
{
if（arrayTask[i].ArriveTime==t）
returni;
}
}
intsjf（）/*定义FCFS中寻找未执行的进程的最先到达时间*/
{
inti,x=0,a=0,b=0;/*判断是不是第一个执行的进程*/
floatg;
for（i=0;i<4;i++）
{
if（arrayTask[i].Status==1）
{g=arrayTask[i].EndTime;
x=1;
}
}
if（x==0）/*第一个执行的进程按FCFS*/
{
t=arrayTask[0].ArriveTime;
for（i=0;i<4;i++）
{
if（arrayTask[i].ArriveTime{t=arrayTask[i].ArriveTime;
a=i;
}
}
returna;}
else
{
for（i=0;i<4;i++）
{if（arrayTask[i].EndTime>g）
g=arrayTask[i].EndTime;
}
for（i=0;i<4;i++）
{if（arrayTask[i].Status==0&&arrayTask[i].ArriveTime<=g）
{t=arrayTask[i].RequestTime;
a=i;
b=1;}/*判断有没有进程在前个进程完成前到达*/
}
if（b!
=0）/*有进程到达则按SJF*/
{for（i=0;i<4;i++）
{
if（arrayTask[i].Status==0&&arrayTask[i].ArriveTime<=g&&arrayTask[i].RequestTime{t=arrayTask[i].RequestTime;
a=i;}
}
returna;}
else{/*否则按FCFS*/
for（i=0;i<4;i++）
{if（arrayTask[i].Status==0）
t=arrayTask[i].ArriveTime;
}
for（i=0;i<4;i++）
{
if（arrayTask[i].Status==0&&arrayTask[i].ArriveTime{t=arrayTask[i].ArriveTime;
a=i;
}
}
returna;}
}
}
new（ints）/*定义执行进程后相关数据的修改*/
{
inti,g=0;
for（i=0;i<4;i++）
{
if（arrayTask[i].Status==0）
continue;
else
{
g=1;
break;
}
}
if（g==0）/*当处理的是第一个未执行的进程时执行*/
{
arrayTask[s].StartTime=arrayTask[s].ArriveTime;
arrayTask[s].EndTime=arrayTask[s].RequestTime+arrayTask[s].ArriveTime;
arrayTask[s].RunTime=arrayTask[s].RequestTime;
arrayTask[s].Status=1;
g=2;
}
if（g==1）/*当处理的不是第一个未执行的进程时执行*/
{
arrayTask[s].Status=1;
for（i=0;i<4;i++）
{
if（arrayTask[i].Status==1）
d=arrayTask[i].EndTime;
}
for（i=0;i<4;i++）/*查找最后执行的进程的完成时间*/
{
if（arrayTask[i].EndTime>d&&arrayTask[i].Status==1）
d=arrayTask[i].EndTime;
}
if（arrayTask[s].ArriveTimearrayTask[s].StartTime=d;
else
arrayTask[s].StartTime=arrayTask[s].ArriveTime;
arrayTask[s].EndTime=arrayTask[s].StartTime+arrayTask[s].RequestTime;
arrayTask[s].RunTime=arrayTask[s].EndTime-arrayTask[s].ArriveTime;
}
arrayTask[s].DQRunTime=arrayTask[s].RunTime/arrayTask[s].RequestTime;
}
Printresult（intj）/*定义打印函数*/
{
printf（"%d\t",arrayTask[j].id）;
printf（"%5.2f\t",arrayTask[j].ArriveTime）;
printf（"%5.2f\t",arrayTask[j].RequestTime）;
printf（"%5.2f\t",arrayTask[j].StartTime）;
printf（"%5.2f\t",arrayTask[j].EndTime）;
printf（"%5.2f\t",arrayTask[j].RunTime）;
printf（"%5.2f\n",arrayTask[j].DQRunTime）;
}
main（）
{inti,b,k,a,c=0;
intd[4];
clrscr（）;
printf（"\tF.FCFS\n"）;
printf（"\tS.SFJ \n"）;
printf（"\tQ.EXIT\n"）;
for（i=0;;i++）
{if（c）
break;
printf（"pleaseinputthenumbera:
\n"）;
scanf（"%d",&a）;
switch（a）
{
caseQ:
c=1;
break;
caseF:
printf（"pleaseinputthedifferent-ArriveTimeofarrayTasks\n"）;
GetTask（）;
printf（"*****************************theresultoffcfs\n"）;
printf（"Number\tArrive\tServer\tStart\tFinish\tTurnove\tTakepowerturnovertime\n"）;
for（b=0;b<4;b++）/*调用两个函数改变结构体数的值*/
{
k=fcfs（）;
d[b]=k;
new（k）;
}
for（b=0;b<4;b++）
Printresult（d[b]）;/*调用打印函数打出结果*/
continue;
caseS:
printf（"pleaseinputthedifferent-RequestTimeofarrayTasks\n"）;
GetTask（）;
printf（"******************************theresultofsjf\n"）;
printf（"Number\tArrive\tRequest\tStart\tEnd\tRun\tDQRuntime\n"）;
for（b=0;b<4;b++）
{
k=sjf（）;
d[b]=k;
new（k）;
}
for（b=0;b<4;b++）
Printresult（d[b]）;
continue;
default:
printf（"thenumberError.pleaseinputanothernumber!
\n"）;
}
}
}
2时间片轮转法：
#include"string.h"
#include "stdio.h"
#include "conio.h"
#include "graphics.h"
#define NULL 0
typedef struct quen /*定义结构*/
{ char pname[8];
int time1;
int time2;
char state;
struct quen *next;
} QUEN;
main（）/*主程序*/
{
QUEN *q,*p,*head,*m;
char str[8],f;
int t,d,n;
clrscr（）;
textmode（C80）;
textbackground（0）;
textcolor（15）;
printf（"Enterthemaxnumberofnodes（n）:
\n"）;/*输入进程数*/
scanf（"%d",&n）;
d=n;
if（d>0）
{ printf（"enterthepname:
"）;
scanf（"%s",str）;
printf（"enter the need time:
"）;
scanf（"%d",&t）;
head=p=（QUEN *）malloc（sizeof（QUEN））;
strcpy（p->pname,str）;
p->time1=t;
p->time2=0;
p->state='R';
p->next=NULL;
head=p;
getchar（）;
--d;}
while（d>0） {/*构建队列表*/
printf（"enter the pname:
"）;
scanf（"%s",str）;
printf（"enter need time:
"）;
scanf（"%d",&t）;
q=（QUEN *）malloc（sizeof（QUEN））;
strcpy（q->pname,str）;
q->time1=t;
q->time2=0;
q->state='R';
q->next=NULL;
p->next=q;
p=q;
--d;
p->next=head;
q=head;}
printf（"processnameneedtimerunnedstatic\n"）;
do{ printf（"%s%d%d%c\n",q->pname,q->time1,q->time2,q->state）;
q=q->next;
}while（q!
=head）;
printf（"\n"）;
do{
if（head->time2time1）
{head->time2++;
if（head->time2==head->time1）
{ head->state='E';
q=head;
textbackground（0）;
printf（"Therunningprocessis%s\n",q->pname）;
printf（"processnamelefttimerunnedstatic\n"）;
do{ textcolor（15）;
/*输入队列表*/
printf（"%s%d%d%c\n",q->pname,q->time1,q->time2,q->state）;
q=q->next;}
while（q!
=head）;
printf（"\n"）;
head=head->next;
q=head;
p->next=head;
}
else{
printf（"Therunningprocessis%s\n",q->pname）;
printf（"processnamelefttimerunnedstatic\n"）;
do{
printf（“%s%d%d%c\n",q->pname,q->time1,q->time2,q->state）;
q=q->next;}while（q!
=head）;
printf（"\n"）;
head=head->next;
q=head;
p=p->next;}
printf（"Isitneedingnewprocess?
（yorn）\n"）;/*是否加入新的进程*/
getchar（）;
scanf（"%c",&f）;
if（f=='Y'||f=='y'）{
getchar（）;
printf（"Enterthenewpname:
"）;
scanf（"%s",str）;
printf（"Enterthenewneededtime:
"）;
scanf（"%d",&t）;
m=（QUEN *）malloc（sizeof（QUEN））;
strcpy（m->pname,str）;
m->time1=t;
m->time2=0;
m->state='R';
m->next=NULL;
if（q->next->state=='E'）
{p=m;
head=m;
p->next=head;
q=head;}
else{p->next=m;
m->next=head;
p=m;}}
}}while（q->next->state!
='E'）;
printf（"Theprocessesarefinished\n"）;
}
3优先级调度方法：
#include
#include "conio.h"
typedef struct pcb/*定义结构*/
{charname[5];
structpcb*next;
int needtime;
int priority;
charstate[5];
}NODE;
NODE *create_process（int n）/*创建队列*/
{NODE *head,*s,*t;
int time,i=0,j;
char pname[5];
head=（NODE *）malloc（sizeof（NODE））;
printf（"please input process name:
"）;
scanf（"%s",pname）;
strcpy（head->name,pname）;
printf（"please input need time:
"）;
scanf（"%d",&time）;
head->needtime=time;
printf（"please input priority:
"）;
升级会员 