操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法.docx

操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法.docx

《操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法.docx》由会员分享，可在线阅读，更多相关《操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法.docx（13页珍藏版）》请在冰豆网上搜索。

操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法

湖南农业大学科学技术师范学院

学生实验报告

姓名：

汤黎波年级专业班级06级计算机教育班日期2008年12月8日成绩

课程名称

计算机操作系统

实验名称

编程进程或作业先来先服务、高优先权、按时间片轮转调度算法（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].ArriveTime

t=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].ArriveTime

arrayTask[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-ArriveTimeof