华东交通大学操作系统实验二作业调度实验(含代码)
作业调度_实验报告

实验名称作业调度实验内容1、设计可用于该实验的作业控制块;2、动态或静态创建多个作业;3、模拟先来先服务调度算法和短作业优先调度算法。
3、调度所创建的作业并显示调度结果(要求至少显示出各作业的到达时间,服务时间,开始时间,完成时间,周转时间和带权周转时间);3、比较两种调度算法的优劣。
实验原理一、作业作业(Job)是系统为完成一个用户的计算任务(或一次事物处理)所做的工作总和,它由程序、数据和作业说明书三部分组成,系统根据该说明书来对程序的运行进行控制。
在批处理系统中,是以作业为基本单位从外存调入内存的。
二、作业控制块J C B(J o b C o nt r o l Bl o ck)作业控制块JCB是记录与该作业有关的各种信息的登记表。
为了管理和调度作业,在多道批处理系统中为每个作业设置了一个作业控制块,如同进程控制块是进程在系统中存在的标志一样,它是作业在系统中存在的标志,其中保存了系统对作业进行管理和调度所需的全部信息。
在JCB中所包含的内容因系统而异,通常应包含的内容有:作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。
三、作业调度作业调度的主要功能是根据作业控制块中的信息,审查系统能否满足用户作业的资源需求,以及按照一定的算法,从外存的后备队列中选取某些作业调入内存,并为它们创建进程、分配必要的资源。
然后再将新创建的进程插入就绪队列,准备执行。
四、选择调度算法的准则1).面向用户的准则(1) 周转时间短。
通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。
所谓周转时间,是指从作业被提交给系统开始,到作业完成为止的这段时间间隔(称为作业周转时间)。
操作系统作业调度实验报告

#define NULL 0
int n;
float T1=0,T2=0;
int times=0;
struct jcb//作业控制块
{
char name[10]; //作业名
int reachtime; //作业到达时间
3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。
3)流程图:
二.最短作业优先算法
三.高响应比算法
图一.先来先服务流程图
4)源程序:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
if(m==3) //显示高响应比算法调度作业后的运行情况
{
printf("\n作业%s正在运行,估计其运行情况:\n",q->name);
printf("开始运行时刻:%d\n",q->starttime);
printf("完成时刻:%d\n",q->finishtime);
printf("周转时间:%f\n",q->cycletime);
struct jcb *next; //结构体指针
}*ready=NULL,*p,*q;
typedef struct jcb JCB;
void inize()//初始化界面
{
printf("\n\n\t\t*********************************************\t\t\n");
操作系统实验报告(进程调度)

华中师范大学计算机科学系《操作系统》实验报告实验题目:进程调度学生姓名:日期:2011-12-9实验2进程调度进程完成,撤消该进程就绪队列首进程投入运行 时间片到,运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】(1)通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
(2)了解Windows2000/XP 中进程(线程)的调度机制。
(3)学习使用Windows2000/XP 中进程(线程)调度算法,掌握相应的与调度有关的Win32 API 函数。
【实验内容】在Windows XP 、Windows 2000等操作系统下,使用的VC 、VB 、java 或C 等编程语言,利用相应的WIN32 API 函数,编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。
【实验步骤、过程】(含原理图、流程图、关键代码,或实验过程中的记录、数据等)1、进程调度算法:采用多级反馈队列调度算法。
其基本思想是:当一个新进程进入内在后,首先将它放入第一个队列的末尾,按FCFS 原则排队等待高度。
当轮到该进程执行时,如能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚为完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS 原则等待调度执行,以此类推。
2、实验步骤:(1)按先来先服务算法将进程排成就绪队列。
(2)检查所有队列是否为空,若空则退出,否则将队首进程调入执行。
(3)检查该运行进程是否运行完毕,若运行完毕,则撤消进程,否则,将该进程插入到下一个逻辑队列的队尾。
(4)是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。
(5)重复步骤(2)、(3)、(4),直到就绪队列为空。
操作系统实验报告-作业调度

作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F']周转时间:带权周转时间:短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:带权周转时间:1.响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:带权周转时间:五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])(li[0])(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间'](work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])(li[-1])(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in ():if ('gb2312')==u'作业名':(x)#print ('gb2312')+":"+str(x)print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间']zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*len(resultlist)))print('带权周转时间:'+str(dqzzsj*len(resultlist))) print('')shunxu(fcfs(list1),'先来先服务算法')shunxu(sjf(list2),'短作业优先算法')shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统实验报告作业调度

操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。
通过编写代码,模拟这些算法的执行过程,并观察它们的效果。
2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。
通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。
实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。
2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。
3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。
4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。
通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
实验二 作业调度实验

西北农林科技大学信息工程学院实习报告课程操作系统学院信息工程专业年级软件151 学号2015012893 姓名张鑫周次第八周交报告时间2017.5.5 成绩实验二作业调度实验一. 目的要求:用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。
二、实验内容:1、编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。
流程图如下:1、响应比高者优先算法流程图:开始初始化所有的JBC,使JBC按作业提交的时间的先后顺序排队时间量times=0先计算队列中所有的作业的响应比,总是西选择响应比最高的走也作为此刻要运行的作业,并修改相应的指针,更改时间量的值不空等待队列空?空计算并打印这组作业的平均周转时间及带权平均周转时间结束2、先来先服务调度算法流程图:3、短作业优先算法调度流程图:实验代码如下:#include<stdio.h> #include<stdlib.h> #include<string.h>struct jcb{char name[10];//作业名float arrtime;//提交时间float waitTime;//等待时间float startTime;//开始时间float runTime;//运行时间float finishTime;//完成时间float TAtime; //周转时间float TAWtimei;//带权周转时间float AvgTAtime,AvgTAWtimei;//平均周转时间;平均带权周转时间 float bi;//响应比};jcb JCB[100];int ReadFile(){int m=0;int i=0;FILE *fp; //定义文件指针fp=fopen("3.txt","r"); //打开文件if(fp==NULL){printf("File open error !\n");exit(0);}else{printf("作业名提交时间运行时间\n");while(!feof(fp)){fscanf(fp,"%s%f%f",&JCB[i].name,&JCB[i].arrtime,&JCB[i].runTime); //fscanf()函数将数据读入printf("\n%s%15f%12f",JCB[i].name,JCB[i].arrtime,JCB[i].runTime); //输出到屏幕i++;}fclose(fp); //关闭文件}m=i-1;return m;}//菜单void menu(){printf("\n\n |*************** 作业调度*************|\n");printf("|======================================|\n");printf(" | 0.退出|\n");printf(" | 1.先来先服务 (FCFS) 调度算法|\n");printf(" | 2.短作业优先 (SJF) 调度算法|\n");printf(" | 3.响应比高者优先 (HRRN) 调度算法 |\n");printf("|======================================|\n");}void displayone(float p,char *h,int i,int j){strcpy(h,JCB[i].name);strcpy(JCB[i].name,JCB[j].name);strcpy(JCB[j].name,h);p=JCB[i].arrtime;JCB[i].arrtime=JCB[j].arrtime;JCB[j].arrtime=p;p=JCB[i].runTime;JCB[i].runTime=JCB[j].runTime;JCB[j].runTime=p;p=JCB[i].startTime;JCB[i].startTime=JCB[j].startTime;JCB[j].startTime=p;p=JCB[i].finishTime;JCB[i].finishTime=JCB[j].finishTime;JCB[j].finishTime=p;}void displaytow(int i,int y){printf("\n");printf("作业%s先开始运行\n\n",JCB[0].name);float AvgCycleTime,AvgValueCycleTime,k=0,m=0;//AvgCycleTime为平均周转时间,AvgValueCycleTime为平均带权周转时间for(i=0;i<y;i++){JCB[0].startTime=JCB[0].arrtime;JCB[i].finishTime=JCB[i].startTime+JCB[i].runTime;//结束时间JCB[i+1].startTime=JCB[i].finishTime;JCB[i].waitTime=JCB[i].startTime-JCB[i].arrtime;//等待时间JCB[i].TAtime=JCB[i].finishTime-JCB[i].arrtime;//周转时间 JCB[i].TAWtimei=JCB[i].TAtime/JCB[i].runTime;//带权周转时间k+=JCB[i].TAtime;m+=JCB[i].TAWtimei;}AvgCycleTime=k/y;//平均旋转时间AvgValueCycleTime=m/y;//平均带权旋转时间printf("作业名提交时间开始时间运行时间结束时间等待时间周转时间带权周转时间\n");for(i=0;i<y;i++)printf("%s\t%.2f\t%.2f\t%4.2f\t%6.2f\t%7.2f\t%7.2f\t%8.2f\n\n",JCB[i] .name,JCB[i].arrtime,JCB[i].startTime,JCB[i].runTime,JCB[i].finishTim e,JCB[i].waitTime,JCB[i].TAtime,JCB[i].TAWtimei);printf("平均周转时间为:");printf("%.2f\n\n",AvgCycleTime);printf("平均带权周转时间为:");printf("%.2f\n\n",AvgValueCycleTime);}void FCFS(int y)//先来先服务算法{float p;int i,j;char h[100];for(i=0;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime){displayone(p,h,i,j);}}}displaytow(i,y);}void SJF(int y)//短作业优先算法{float p;int i,j;char h[100];for(i=0;i<y;i++)//先提交的作业先运行,后面来的作业再比较运行时间长短{for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime)//先把作业按提交时间来排序{displayone(p,h,i,j);}}}for(i=1;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].runTime>JCB[j].runTime)//比较后面来的作业的运行时间{displayone(p,h,i,j);}}}displaytow(i,y);}void HRRN(int y)//响应比高者优先算法{int i,j;float p;char h[100];for(i=0;i<y;i++)//先提交的作业先运行,后面来的作业再比较响应比的大小{for(j=i+1;j<y;j++){if(JCB[i].arrtime>JCB[j].arrtime)//先把作业按提交时间来排序{displayone(p,h,i,j);}}}for(i=0;i<y;i++){JCB[0].startTime=JCB[0].arrtime;JCB[i].finishTime=JCB[i].startTime+JCB[i].runTime;//结束时间JCB[i+1].startTime=JCB[i].finishTime;JCB[i].waitTime=JCB[i].startTime-JCB[i].arrtime;//等待时间JCB[i].TAtime=JCB[i].finishTime-JCB[i].arrtime;//周转时间 JCB[i].bi=JCB[i].TAtime/JCB[i].runTime;//响应比}for(i=1;i<y;i++){for(j=i+1;j<y;j++){if(JCB[i].bi<JCB[j].bi)//比较后面来的作业的响应比{displayone(p,h,i,j);p=JCB[i].bi;JCB[i].bi=JCB[j].bi;JCB[j].bi=p;}}}displaytow(i,y);for(i=1;i<y;i++){printf("%s的响应比为:%.2f\n",JCB[i].name,JCB[i].bi);}}int main(){while(1){int i,x,n;menu();loop1:printf("请选择模块(0~3): ");scanf("%d",&i);if(i==0){exit(0);}elseif(i<=0||i>3){printf("输入有误,请重新输入\n");goto loop1;//无条件转移语句}loop2:printf("原始数据是:\n");n=ReadFile();for(x=0;x<n;x++){printf("\n%s%15f%12f",JCB[i].name,JCB[i].arrtime,JCB[i].runTime);}switch(i){case 0:exit(0);break;case 1:FCFS(n);break;case 2:SJF(n);break;case 3:HRRN(n);break;}}}实验截图说明如下:这是先来先服务算法调度这是最短优先作业调度算法结果这是响应比高者优先调度算法结果2、编写并调度一个多道程序系统的作业调度模拟程序。
操作系统作业调度实验

实验二作业调度一、实验名称作业调度算法的模拟实现二、实验目标作业调度又称宏观调度,其主要任务是对磁盘设备上大量的后备作业,以一定的原则进行挑选,给选中的作业分配内存等必须的资源,建立其相应的进程,让其投入运行。
本实验要求学生用高级程序设计语言编写和调试一个简化的作业调度程序,模拟实现的调度算法包括:先来先服务调度算法,短作业优先调度算法,响应比高者优先调度算法等,并对这些算法的性能做比较和评价。
以加深学生对作业、作业调度以及作业调度的各种算法的理解。
三、实验环境要求Windows+Visual C++ 6.0;四、实验基本原理作业调度主要是完成作业从后备状态到执行状态的转变,以及从执行状态到完成状态的转变。
(1)创建JCB(作业控制块):系统在作业进入后备状态时为每个作业创建一个作业控制块(JCB),从而使该作业可被调度程序感知。
当该作业执行完毕进入完成状态时候,系统自动撤销其JCB并释放有关资源,进而撤销该作业。
(2)按照作业调度算法,从后备队列中挑选一作业投入运行。
作业调度程序为运行作业建立相应的进程,并分配资源。
(3)主要的作业调度算法包括:先来先服务(FCFS)、短作业优先和最高响应比。
(4)调度策略的指标:最常用的调度性能指标有,周转时间(带权)、吞吐率、响应时间以及设备利用率。
五、数据结构设计(1)作业控制块,包括作业的基本信息描述。
struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};六、流程图图1 作业调度算法流程图七、源代码#include <iostream>#include <string>using namespace std;struct time //时间的数据结构{int hour;int minute;};struct Job //作业{string jobname; //作业名time intime; //进入时间int runtime; //作业估计运行时间time starttime; //作业开始时间time endtime; //作业结束时间int cycletime; //作业周转时间float cltime; //作业带权周转时间bool haverun; //是否已运行};float T=0;//作业平均周转时间float W=0;//作业带权平均周转时间void showInput(Job job[],int &n) //输入提示{cout<<"**********请按作业进入时间先后顺序输入*********"<<endl;for(int i=0;i<n;i++){cout<<"作业"<<i+1<<":"<<endl;cout<<"作业名:";cin>>job[i].jobname;cout<<"作业进入时间:";scanf("%d:%d",&job[i].intime.hour,&job[i].intime.minute);cout<<"作业估计运行时间:";cin>>job[i].runtime;job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行cout<<"*********************"<<endl;}}void Init(Job job[],int &n)//初始化{for(int i=0;i<n;i++){job[i].starttime.hour=0;job[i].starttime.minute=0;job[i].endtime.hour=0;job[i].endtime.minute=0;job[i].cycletime=0;job[i].cltime=0;job[i].haverun=false; //标记为未运行}T=0;W=0;}void showTime(time time) //显示时间{cout<<time.hour<<":"<<time.minute;}int timeDiff(time t1,time t2) //计算时间差,时间t1比t2大{return t1.hour*60+t1.minute-(t2.hour*60+t2.minute);}time timeAdd(time time,int addtime) //时间相加{time.hour+=addtime/60;time.minute+=addtime%60;if(time.minute>=60){time.hour++;time.minute-=60;}return time;}bool comtime(time t1,time t2)//比较两个时间的大小,第一个大就返回TRUE {if(t1.hour>t2.hour)return true;else if(t1.hour==t2.hour&&t1.minute>=t2.minute)return true;elsereturn false;}void showResult(Job job[],int &n) //显示结果{cout<<"jobname\tintime\truntime\tsttime\tendtime\t周转时间(分钟)\t带权周转时间"<<endl;cout<<"*********************************************************** ********"<<endl;for(int i=0;i<n;i++){cout<<job[i].jobname<<"\t";showTime(job[i].intime);cout<<"\t"<<job[i].runtime<<"\t";showTime(job[i].starttime);cout<<"\t";showTime(job[i].endtime);cout<<"\t "<<job[i].cycletime<<"\t\t "<<job[i].cltime<<endl;}cout<<"作业平均周转时间:T="<<T/(n*1.0)<<endl;cout<<"作业带权平均周转时间:W="<<W/(n*1.0)<<endl;}int minRuntime(Job job[],int &n,time &t) //找出作业中最短作业下标{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false && comtime(t,job[i].intime)==true){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && job[j].runtime<job[min].runtime && comtime(t,job[j].intime)==true)min=j;return min;}void SJF(Job job[],int &n)//短作业优先作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(minRuntime(job,n,t)!=-1){int i=minRuntime(job,n,t);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}int Firstintime(Job job[],int &n) //找出作业中最先到的{int min=-1;for(int i=0;i<n;i++){if(job[i].haverun==false){min=i;break;}}for(int j=min+1;j<n;j++)if(job[j].haverun==false && comtime(job[min].intime,job[j].intime)) min=j;return min;}void FCFS(Job job[],int &n)//先来先服务作业调度{struct time t;job[0].starttime.hour=job[0].intime.hour;job[0].starttime.minute=job[0].intime.minute;job[0].endtime=timeAdd(job[0].starttime,job[0].runtime);job[0].haverun=true;job[0].cycletime=timeDiff(job[0].endtime,job[0].intime);job[0].cltime=job[0].cycletime*1.0/job[0].runtime;T+=job[0].cycletime;W+=job[0].cltime;t=job[0].endtime;while(Firstintime(job,n)!=-1){int i=Firstintime(job,n);if(comtime(job[i].intime,t))job[i].starttime=job[i].intime;elsejob[i].starttime=t;job[i].endtime=timeAdd(job[i].starttime,job[i].runtime);job[i].haverun=true;job[i].cycletime=timeDiff(job[i].endtime,job[i].intime);job[i].cltime=job[i].cycletime*1.0/job[i].runtime;T+=job[i].cycletime;W+=job[i].cltime;t=job[i].endtime;}}void main(){cout<<"请输入作业数:";int n; //作业数cin>>n;Job *job=new Job[n];if(n<=0){cout<<"输入不合法!";exit(-1);}else{showInput(job,n);cout<<endl;FCFS(job,n);cout<<"先来先服务:"<<endl;showResult(job,n);cout<<endl;Init(job,n);SJF(job,n); //短作业优先cout<<"短作业优先:"<<endl;showResult(job,n);}system("pause");}八、运行结果用户输入作业的相关信息,程序输出相应的各种算法运行结果。
操作系统实验报告二附代码

}
void init(){
int i;
for(i=0;i<100;i++){
process[i].ArrivalTime=0;
process[i].ServiceTime=0;
process[i].PServiceTime=0;
process[i].FinishTime=0;
process[i].WholeTime=0;
process[i].WeightWholeTime=0;
process[i].Finished=false;
process[i].Arrival=false;
}
AverageWT=0;
AverageWWT=0;
}
void input(){
int i;
cout<<"请输入进程数n=";
if(process[i].PServiceTime==process[i].ServiceTime&&process[i].Arrival==false)
{
if(process[i].ArrivalTime<=time)
int ArrivalTime;
int ServiceTime;
int PServiceTime;
int FinishTime;
int WholeTime;
double WeightWholeTime;
bool Finished;
bool Arrival;
}Pro;
Pro process[100];
cin>>n;
cout<<"请输入"<<n<<"个进程名:";
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
选择 3 进入“响应比高者优先算法”作业调度:
float super;
//作业的响应比
int finishtime;
//作业完成时间
float cycletime;
//作业周转时间
float cltime;
//作业带权周转时间
char state;
//作业状态
struct jcb *next;
//结构体指针
}*ready=NULL,*p,*q;
typedef struct jcb JCB;
void inize()
//初始化界面
{
printf("\n\n\t\t*********************************************\t\t\n");
printf("\t\t\t\t 单道批处理作业调度系统\n");
printf("\t\t*********************************************\t\t\n");
printf("\n\n\n\t\t\t1.先来先服务算法"); printf("\n\t\t\t2.最短作业优先算法"); printf("\n\t\t\t3.响应比高者优先算法"); printf("\n\t\t\t0.退出程序"); printf("\n\n\t\t\t\t 选择算法:"); scanf("%d",&m); switch(m) {
times+=p->needtime;
p->state='F';
printf("\n%s 作业已完成!\n 请按任意键继续...\n",p->name);
free(p);
//释放运行后的作业
getch();
}
void super()
//计算队列中作业的高响应比
{
JCB *padv;
padv=ready;
case 1: fcfs(m); getch(); system("cls");
mune();
break;
case 2:
sjf(m);
getch();
system("cls");
mune();
break;
case 3:
hrn(m);
getch();
system("cls");
mune();
break;
if(iden)
{
min=p;iden=0;
}
else if(p->super>min->super) min=p;
p=p->next;
}while(p!=NULL);
if(iden)
{
i--;times++;
if(times>1000)
{printf("\nruntime is too long...error...");getch();}
}
void fcfs(int m) //先来先服务算法
{
int i,iden;
system("cls");
inital();
for(i=0;i<n;i++)
{
p=ready;iden=1;
do{
if(p->state=='W'&&p->reachtime<=times) iden=0;
if(iden)p=p->next;
实验二 作业调度实验
一 . 目的要求:
用高级语言编写和调试作业调度的模拟程序,以加深对作业调度算法的理 解。
二、实验要求: 为单道批处理系统设计一个作业调度程序。
由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直 到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足、它所 占用的 CPU 时限等因素。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权
周转时间,这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均
周转时间。
源代码:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
}
else
{
running(min,m);
//调用 running()函数
}
} //for
final();
//调用 running()函数
}
void sjf(int m)
// 最短作业优先算法
{
JCB *min;
int i,iden;
system("cls");
inital();
for(i=0;i<n;i++)
}while(p!=NULL&&iden) ;
if(iden)
{
i--;
printf("\n 没有满足要求的进程,需等待");
times++;
if(times>100){printf("\n 时间过长");getch();}
}
else{
running(p,m); //调用 running()函数
}
}
{
p=min=ready;iden=1;
do{
if(p->state=='W'&&p->reachtime<=times)
if(iden){
min=p;iden=0;
}
else if(p->needtime<min->needtime) min=p;
p=p->next;
}while(p!=NULL) ;
printf("\n\n\n\t\t\t\t\t09 软件+电子商务 2 班\n");
printf("\t\t\t\t\t\t 黄才旺\n\n");
printf("\n\n\n\t\t 请按任意键进入主菜单:");
getch();
}
void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列
printf(" %f \t",q->cycletime);
printf(" %f\t",q->cltime);
getch();
}
}
void running(JCB *p,int m)
//运行作业
{
if(p==ready)
//先将要运行的作业从队列中分离出来
{
ready=p->next;
p->next=NULL;
}
void final()源自//最后打印作业的平均周转时间,平均带权周转时间
{
float s,t;
t=T1/n;
s=T2/n;
getch();
printf("\n\n 作业已经全部完成!");
printf("\n%d 个作业的平均周转时间是:%f",n,t);
printf("\n%d 个作业的平均带权周转时间是:%f\n\n\n",n,s);
printf("
%d \t",q->finishtime);
printf(" %f \t",q->cycletime);
printf(" %f\t",q->cltime);
printf(" %f\n",q->super);
getch();
}
else
// 显示先来先服务,最短作业优先算法调度后作业的运行
p->cycletime=(float)(p->finishtime-p->reachtime);
p->cltime=(float)(p->cycletime/p->needtime);
T1+=p->cycletime;
T2+=p->cltime;
disp(p,m);
//调用 disp()函数,显示作业运行情况
{
int i;
printf("\n 输入作业数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
p=getpch(JCB);
printf("\n 输入作业名:");
scanf("%s",p->name);
getch();
p->reachtime=i;
printf("作业默认到达时间:%d",i);
}
void hrn(int m)
//高响应比算法
{
JCB *min;
int i,iden;
system("cls");
inital();
for(i=0;i<n;i++)
{
p=min=ready;iden=1;