操作系统作业调度实验报告

合集下载

作业调度_实验报告

作业调度_实验报告

实验名称作业调度实验内容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) 周转时间短。

通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。

所谓周转时间,是指从作业被提交给系统开始,到作业完成为止的这段时间间隔(称为作业周转时间)。

作业调度实验报告

作业调度实验报告

作业调度实验报告一、实验目的1.掌握作业调度的概念和基本原则;2.理解作业调度算法的原理和实现方式;3.熟悉作业调度过程中的各种参数和指标;4.进一步了解操作系统中的进程调度机制。

二、实验环境本次实验使用的操作系统环境为Windows平台。

三、实验内容1.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;2.设计一个作业队列,模拟一系列作业的到达和执行过程;3.根据作业调度算法,将作业分配给CPU执行,并统计作业的等待时间、完成时间等指标;4.进行多次实验,比较不同调度算法之间的性能差异。

四、实验步骤1.首先,设计一个作业类,包括作业的名称、重要性、到达时间和执行时间等属性;2.定义一个作业队列,用于存储到达的作业,并按照到达时间进行排序;3.实现一个简单的作业调度算法,根据作业的重要性和执行时间进行优先级排序;4.设计一个CPU类,用于执行作业队列中的作业,并记录作业的等待时间、完成时间等指标;5.模拟一系列作业的到达和执行过程,将作业调度给CPU执行,并记录相关指标;6.分别使用不同的调度算法进行多次实验,比较各自的性能差异。

五、实验结果与分析通过多次实验,得到了不同调度算法下的作业等待时间、完成时间等指标,并进行了比较。

结果发现,在作业执行时间相同时,按照作业的重要性进行优先级排序的算法,能够使得较重要的作业尽早执行,因而整体的作业等待时间和完成时间较短。

而对于作业执行时间不一致的情况,采用短作业优先算法,可以使作业平均等待时间较短,但在一些较长的作业上可能会存在饥饿现象。

综合考虑作业的重要性和执行时间,采用带权重的优先级队列算法可以获得较好的调度效果。

六、实验总结通过本次实验,我深入了解了作业调度的概念、原理和实现方式。

通过对比不同调度算法的性能差异,对于实际的作业调度过程具有一定的指导意义。

此外,通过实验设计和代码实现,我也提高了编程和分析问题的能力。

总体而言,本次实验使我对操作系统中的作业调度有了更为深刻的理解,并提高了我的实践能力。

操作系统实验报告进程调度

操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。

其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。

实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。

实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。

在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。

实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。

在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。

2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。

在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。

3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。

在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。

实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。

在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。

因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。

结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。

同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。

操作系统实验报告-作业调度

操作系统实验报告-作业调度

作业调度一、实验目的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),'响应比高者优先算法')。

操作系统试验报告一处理机调度

操作系统试验报告一处理机调度

实验课程名称:实验项目名称处理机调度 实验成绩实验者专业班级名且另IJ同组者实验日期年 月 日第一部分:实验分析与设计(可加页)一、 实验内容描述(问题域描述)实验目的:掌握处理机调度的相关内容,对进程调度算法有深入理解。

实验内容:模拟实现进程调度功能。

实验要求:1、任选一种高级语言实现;2、选择1-2种调度算法;3、能够输入进程的基本信息,如进程名、提交时间、预估运行时间等;4、根据选择的调度算法显示进程调度顺序;5、显示完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;6、计算平均周转时间和平均带权周转时间。

二、 实验基本原理与设计(包括实验方案设计,实验手段的确定,试验步骤等,用硬件逻辑或者算法描述) 数据结构:一个作业的描述结构: struct WORK {int num;//进程序号startTim;//开始时间 upTim;//提交时间 offTim;//结束时间 costTim;//耗费时间长度 Ti;//周转时间 Tr;//带权周转时间输出模块float floatfloat floatfloat float };功能说明:输入模块、输出模块:负责进程的输入及模拟结果的输出;处理机调度函数调用模块:选择调用算法完成进程调度;先入先出算法模拟模块、短进程优先算法模拟模块:实际完成模拟调度功能;相关时间计算模块:计算开始时间、结束时间,周转时间,带权周转时间。

三、主要仪器设备及耗材硬件:pc机;软件:windows2007旗舰版、VS 2010开发环境。

第二部分:实验调试与结果分析(可加页)一、实验源程序:# include <iostream>using namespace std;struct WORK{int num;//进程序号float startTim;//开始时间float upTimJ/提交时间float offTim;//结束时间float costTim;//耗费时间长度float Ti;〃周转时间float Tr;//带权周转时间};void FIFO(WORK *workspace,int workNum);void SJF(WORK *workspace,int workNum);void SUM(WORK *workspace,int workNum,float *T,float *W);int main(){int num;float upTim;float costTim;int workNum;cout<<"请输入需要被调度的作业的数目:"<<endl;cin>>workNum;WORK *workspace=new WORK[workNum];cout<<"请依次输入需要被调度的作业(输入格式:作业序号作业提交时间(用数字表示) 执行时间):"<<endl;int n=0;while(cin>>num>>upTim>>costTim && n<workNum){workspace[n].num=num;workspace[n].upTim=upTim;workspace[n].costTim=costTim;n++;}cin.clear();cin.sync();cout<<"作业序号\t作业提交时间\t执行时间):"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t<<workspace[i].costTim<<endl;/****************** 选择算法,执行算法,结果输出*****************/int cho=0;float * T=new float[0],* W=new float[0];cout<<"请选择调度算法:"<<endl;cout<<0<<"--->FIFO\n"<<1<<"--->最短优先"<<endl;cin>>cho;switch(cho){case 0:FIFO(workspace,workNum);SUM(workspace,workNum,T,W);break;case 1:SJF(workspace,workNum);SUM(workspace,workNum,T,W);break;}cout<<"执行顺序"<<"\t"<<"提交时间"<<"\t"<<"执行时间"<<"\t"<<"开始时间"<<"\t"<<"结束时间"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t"<<workspace[i].costTim <<"\t\t"<<workspace[i].startTim<<"\t\t"<<workspace[i].offTim<<endl;}cout<<"平均周转时间:"<<(*T)/workNum<<"\t 平均带权周转时间:"<<(*W)/workNum<<endl;system("PAUSE"); return 0;}void FIFO(WORK *workspace,int workNum)for(int i=0;i<workNum-1;i++) 〃按提交时间排序for(int j=0;j<workNum-1;j++)if(workspace[j].upTim>workspace[j+1].upTim) 〃大数沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j];workspace[j]=temp;}}void SJF(WORK *workspace,int workNum){float MinUptime=0;//最早的提交时间FIFO(workspace,workNum);//先按提交时间排序MinUptime=workspace[0].upTim+workspace[0].costTim;for(int i=0;i<workNum-1;i++) 〃按照最短的作业时间排序for(int j=1;j<workNum-1;j++){if(workspace[j].upTim<MinUptime&&workspace[j+1].upTim<MinUptime) {if(workspace[j].costTim>workspace[j+1].costTim) 〃提交时间大且耗时多的作业沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j]; workspace[j]=temp;}} else {MinUptime=workspace[j].upTim+workspace[j].costTim;//更新}}}void SUM(WORK *workspace,int workNum,float *T,float *W){*T=0;*W=0;for(int i=0;i<workNum;i++)//计算开始时间、结束时间,周转时间,带权周转时间{ if(i==0)//计算第一个作业{workspace[i].startTim=workspace[i].upTim;workspace[i].offTim=workspace[i].upTim+workspace[i].costTim;workspace[i].Ti=workspace[i].offTim-workspace[i].upTim;workspace[i].Tr=workspace[i].Ti/workspace[i].costTim;}else//计算第一个作业基础上的其他作业相关时间{if(workspace[i-1].offTim<workspace[i].upTim)workspace[i].startTim=workspace[i].upTim;elseworkspace[i].startTim=workspace[i-1].offTim;workspace[i].offTim=workspace[i].costTim+workspace[i].startTim; workspace[i].Ti=workspace[i].offTim-workspace[i].upTim; workspace[i].Tr=workspace[i].Ti/workspace[i].costTim; }*T+=workspace[i].Ti;//计算平均周转时间 *W+=workspace[i].Tr;//计算平均带权周转时间 } } 二、 实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)测试用例一结果:请依次前A 需要被洞度的作止:葡人格式;作出序号 执行时间M 1 10 2,眼糟翎要被调度的作业(输入格式:作业序号1 10 2作止提交升间1用道字表示)|2 10.2 1 1? 10a 4 0a 5 L 10a 5 0a 2■(此序]作业提父H J 闫 L 10Z 10.23 10.4k10.5青选择调度算法:0——>FIF0 i-—>最超优先 执行时间), 暨 1 0.5 0.3a 二顺序提交时间 执行时间开始时间结束时间1 10210 12,10.2i 12 13 卜 10.4 8.5 13 13.E 口 1Q.5 0.3平均周转时间.2.8 平均带权周转时间吗.26岛北旺京银继纨 -±3.513.8邛业序与 作北提交时、日h 1M 执行时间)।21«.2 13 10.4 0.5 MIB.E情选区调度算法,同——>FIF0 口一》最短优先 0.3执行顺序 提交时间1 10 执行时间 2开始时间10 结克时间 124IB.E 0.3 12 12.3 10.4 0.5 12.3 12.81M-21句周转时间:2.45平均带权周转时间:3.8512.JS13=8日数据细撷处理机调度废锚纵员或吐理挑洞庭模物n京葡a 需要神话后日作业的数诸输妻萼猫调康的作斗的豹目:2 1M-2 1 □ 10.4 0.5 4 10-5 0,3回作业提交时间(用数字表。

操作系统实验5-调度

操作系统实验5-调度

实验五调度一、基本信息二、实验内容在设计一个按优先级进行调度的算法(1(2的进程(3)调度时,总是选择优先级最高的执行,并采用动态调度:每运行一次优先级减1,估计运行时间减1(4)进程运行一次后,若剩余的运行时间不为0,且优先级低于就绪队列中的进程,则状态变为ready,并选择一个进程使用CPU;若剩余的运行时间为0,则状态变为完成(5)如就绪队列不空,则重复(3)(4)直到所有进程都结束三、实验目的通过实验,巩固和加深对进程调度的理解,以及各种调度算法的基本实现思想。

四、设计思路和流程图(1)用一个结构体构造进程块,记录进程的各个属性,优先级和估计运行时间随机产生(2)创建一个进程块链表,每个节点表示一个进程块。

用head指针表示链表头部,用curPCB表示当前CPU调度的进程块(3)遍历链表,找到优先级最高的进程“运行”(4)重复调度进直到就绪队列中没有进程时,程序运行结束五、主要数据结构及其说明#include <cstdio>#include <random>#include <time.h>struct PCB{int id;int priority;//数值越大,优先级越高PCB* nextPCB;//指向就绪队列中下一个进程的PCB首址int probTime;//估计运行时间int state;//0: ready, 1: running, 2:finished};void main(){srand((unsigned)time(0));struct PCB *temp = new struct PCB;const int cnt = 3;struct PCB *head = temp;for(int i=0; i<cnt; ++i){temp->id = i;temp->priority = rand() % 10 + 1;temp->probTime = rand() % 10 + 1;temp->state = 0;temp->nextPCB = (i == (cnt-1))?0:new struct PCB;temp = temp->nextPCB;}int max = 0;//最高优先级struct PCB *curPCB;//正在执行的进程int countOfPro = cnt;//记录当前剩余进程数while(countOfPro != 0){for(struct PCB *p = head; p != 0; p = p->nextPCB) {if(p->state != 2 && p->priority > max){max = p->priority;curPCB = p;}}curPCB->priority--;curPCB->probTime--;if(curPCB->probTime <= 0){curPCB->state = 2;countOfPro--;}max = -99999;//打印运行后的进程属性内容printf("current proccess is %d ",curPCB->id);printf("priority is %d ", curPCB->priority);printf("rest time is %d\n", curPCB->probTime);}system("pause");return;}六、程序运行时的初值和运行结果七、实验体会此次实验模拟了系统进程调度,进一步学习了进程调度的机制,加深了对调度的理解。

操作系统实验报告作业调度

操作系统实验报告作业调度

操作系统实验报告作业调度操作系统实验报告:作业调度引言作业调度是操作系统中的重要部分,它负责管理和调度系统中的各种作业,以最大化系统资源的利用率和提高作业的执行效率。

在本次实验中,我们将探讨作业调度的基本原理和实现方法,并通过实验验证其效果。

实验目的本次实验的主要目的是通过实际操作,了解作业调度的基本原理和实现方法,掌握作业调度的相关算法,并通过实验验证其有效性。

实验内容1. 实现作业调度的基本算法在本次实验中,我们将实现作业调度的基本算法,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。

通过编写代码,模拟这些算法的执行过程,并观察它们的效果。

2. 实验验证我们将设计一些测试用例,通过模拟作业的执行过程,分别使用不同的作业调度算法,并比较它们的执行效果。

通过实验验证,我们将得出不同算法的优劣势,并分析其适用场景。

实验结果经过实验验证,我们得出以下结论:1. 先来先服务(FCFS)算法适用于作业执行时间相对均匀的情况,但可能会导致平均等待时间较长。

2. 最短作业优先(SJF)算法能够最大程度地减少平均等待时间,但可能会出现作业饥饿现象。

3. 优先级调度(Priority Scheduling)算法能够根据作业的优先级进行调度,适用于有明确优先级需求的情况。

4. 多级反馈队列调度(Multilevel Feedback Queue Scheduling)算法能够根据作业的执行情况动态调整优先级,适用于各种类型的作业。

结论作业调度是操作系统中的重要组成部分,不同的作业调度算法适用于不同的场景。

通过本次实验,我们深入了解了作业调度的基本原理和实现方法,掌握了不同算法的优劣势,并通过实验验证了它们的有效性。

这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。

操作系统实验报告——调度算法

操作系统实验报告——调度算法

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法,通过编写代码模拟不同的调度算法,了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux,并采用C语言进行编码。

3. 实验内容3.1 调度算法1:先来先服务(FCFS)FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中,我们使用C语言编写代码模拟FCFS算法的调度过程,并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2:最短作业优先(SJF)SJF调度算法是一种非抢占式的调度算法,根据进程的执行时间来选择下一个要执行的进程。

在本实验中,我们使用C语言编写代码模拟SJF算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3:轮转调度(Round Robin)Round Robin调度算法是一种经典的时间片轮转算法,每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片,进程将被暂时挂起,等待下一次轮转。

在本实验中,我们使用C语言编写代码模拟Round Robin算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析,可以得出以下结论:- FCFS算法适用于任务到达的先后顺序不重要的场景,但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景,能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况,能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#define getpch(type) (type*)malloc(sizeof(type))
#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");
times+=p->needtime;
p->state='F';
printf("\n%s has been finished!\npress any key to continue...\n",p->name);
free(p); //释放运行后的作业
int starttime; //作业开始时间
int needtime; //作业需要运行的时间
float super; //作业的响应比
int finishtime; //作业完成时间
float cycletime; //作业时间
char state; //作业状态
printf("\t\t\t\t实验二 作业调度\n");
printf("\t\t*********************************************\t\t\n");
printf("\n\n\n\t\t\t\t\t计算机学院软件四班\n");
printf("\t\t\t\t\t蓝小花\n");
printf("完成时刻:%d\n",q->finishtime);
printf("周转时间:%f\n",q->cycletime);
printf("带权周转时间:%f\n",q->cltime);
getch();
}
}
void running(JCB *p,int m)//运行作业
{
if(p==ready) //先将要运行的作业从队列中分离出来
printf("\t\t\t\t\t3204007102\n");
printf("\t\t\t\t\t完成日期:2006年11月17号");
printf("\n\n\n\t\t请输入任意键进入演示过程\n");
getch();
}
void inital()//建立作业控制块队列,先将其排成先来先服务的模式队列
printf("带权周转时间:%f\n",q->cltime);
printf("相应比:%f\n",q->super);
getch();
}
else // 显示先来先服务,最短作业优先算法调度后作业的运行情况
{
printf("\n作业%s正在运行,估计其运行情况:\n",q->name);
printf("开始运行时刻:%d\n",q->starttime);
printf("\n输入作业要运行的时间:");
scanf("%d",&p->needtime);
p->state='W';
p->next=NULL;
if(ready==NULL) ready=q=p;
else{
q->next=p;
q=p;
}
}
}
void disp(JCB* q,int m)//显示作业运行后的周转时间及带权周转时间等
{
ready=p->next;
p->next=NULL;
}
else
{
q=ready;
while(q->next!=p) q=q->next;
q->next=p->next;
}
p->starttime=times; //计算作业运行后的完成时间,周转时间等等
p->state='R';
p->finishtime=p->starttime+p->needtime;
操作系统作业调度实验报告
执行程序: zuoye.exe
2)实验分析:
1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。
2、每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。
{
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);
p->cycletime=(float)(p->finishtime-p->reachtime);
p->cltime=(float)(p->cycletime/p->needtime);
T1+=p->cycletime;
T2+=p->cltime;
disp(p,m); //调用disp()函数,显示作业运行情况
相关文档
最新文档